Binary Search Tree

Terms
Path - Path refers to the sequence of nodes along the edges of a tree
Root - The node at the top of the tree is called root.
         . There is ONLY one root per tree
         . There is Only one path from root node to any node.

Parent - Any node ( except the root node) has one edge upward to a node called parent.
Child  - The node below a given node connected by its edge downward is called its child node.
Leaf - The node which does not have any child node is called the leaf node.
Subtree - Subtree represents the descendants of a node.
Visiting - Visiting refers to checking the value of a node when control is on the node.
Traversing - Traversing means passing through nodes in a specific order.
Levels - Level of a node represents the generation of a node. If the root node is at level 0, then its next child is at level1,
         its grandchild is at level 2, and so on.
         this is height of a three, from 0.
Keys - Key represents a value of a node based on which a search operation is to be carried out for a node.


Binary Search Tree Representation
A node's left child must have a value less than its parent's value and the node's right child must have a value greater than its parent value.


golang code

Basic Operations
Insert                         - Insert an element in a tree/create a tree
Search                       - Searches an element in a tree
Preorder Traversal    - Traverses a tree in a pre-order manner.
Inorder Traversal      - Traverses a tree in an in-order manner.
Postorder Traversal - Traverses a tree in a post-order manner.


Insert Operation
The very first insertion creates the tree. Afterwards, whenever an element is to be inserted, first locate its proper location.
Start searching from the root node, the if the data is less than the key value, search for the empty location in the left subtree and insert the data.
Otherwise, search for the empty location in the right subtree and insert the data.

golang code

Search Operation
Whenever an element is to be searched, start searching fromo the root node, then if the data is less than the key value, search for the element in the left
subtree. Otherwise, search for the element in the right subtree. Follow the same algorighm for each node.

golang code


Traverse Operation
Traversal is a process to visit all the nodes of a tree.Because, all nodes are connected via edges we always start from the root node.
That is, we cannot randomly access a node in a tree. There are three ways which we use to traverse a tree:
  .In-order Traversal
  .Pre-order Traversal
  .Post-order Traversal

In-order Traversal
In this traversal method, the left subtree is visited first, then the root and later the right subtree.
* We should always remember that every node may represent a subtree itself.

If a binary tree is traversed in-order, the output will produce sorted key values in an ascending order.



We start from A, and following in-order traversal, we move to its left subtree B. B is also traversed in-order.
The process goes on until all the nodes are visited. The output of inorder traversal of this tree will be:
D -> B -> E -> A -> F -> C -> G

Pre-order Traversal
In this traversal method, the root node is visited first, then the left subtree and finally the right subtree.
We start from A, and following pre-order traversal, we first visit A itself and then move to its left subtree B.
B is also traversed pre-order. The process goes on until all the nodes are visited.
The output of pre-order traversal of this tree will be:
A -> B -> D -> E -> C -> F -> G


Post-order Traversal
In this traversal method, the root node is visited last, hense the name.
First we traverse the left subtree, then the right subtree and finally the root node.
We start from A, and following Post-order traversal, we first visit the left subtree B.
B is also traversed post-order. The process goes on until all the nodes are visited.
The output of post-order traversal of this tree will be:
D -> E -> B -> F -> G -> C -> A

 Golang:

package binary_search_tree

import (
    "fmt"
)

type Node struct {
    Data       int
    LeftChild  *Node
    RightChild *Node
}

type BinarySearchTree struct {
    Root *Node
}

func (bst *BinarySearchTree) Insert(data int) {
    tmpNode := &Node{data, nil, nil}

    if bst.Root == nil {
        bst.Root = tmpNode // create root node
        return
    }

    var parent *Node
    current := bst.Root

    for true {
        parent = current
        if data < parent.Data {
            current = parent.LeftChild
            if current == nil {
                parent.LeftChild = tmpNode
                return
            }
        } else {
            current = parent.RightChild
            if current == nil {
                parent.RightChild = tmpNode
                return
            }
        }
    }
}

func (bst *BinarySearchTree) Search(data int) *Node {
    if bst.Root == nil {
        fmt.Println("binary search tree is empty.")
        return nil
    }

    fmt.Printf("Visiting elements %d, path:", data)
    current := bst.Root

    for current.Data != data {
        if current != nil {
            fmt.Printf(" -> %d", current.Data)
        }

        if data < current.Data {
            current = current.LeftChild
        } else {
            current = current.RightChild
        }

        if current == nil {
            fmt.Printf(" >> %d not found
", data)
            return nil
        }
    }

    fmt.Printf(" -> %d found
", data)
    return current
}

func traverseInOrder(root *Node) {
    if root == nil {
        return
    }

    // visit left child
    if root.LeftChild != nil {
        traverseInOrder(root.LeftChild)
    }

    // visit root
    fmt.Printf(" %d", root.Data)

    // visit right child
    if root.RightChild != nil {
        traverseInOrder(root.RightChild)
    }
}

func traversePreOrder(root *Node) {
    if root == nil {
        return
    }

    // visit root
    fmt.Printf(" %d", root.Data)

    // visit left child
    if root.LeftChild != nil {
        traversePreOrder(root.LeftChild)
    }

    // visit right child
    if root.RightChild != nil {
        traversePreOrder(root.RightChild)
    }
}

func traversePostOrder(root *Node) {
    if root == nil {
        return
    }

    // visit left child
    if root.LeftChild != nil {
        traversePostOrder(root.LeftChild)
    }

    // visit right child
    if root.RightChild != nil {
        traversePostOrder(root.RightChild)
    }

    // visit root
    fmt.Printf(" %d", root.Data)
}

func (bst *BinarySearchTree) TraverseInOrder() {
    if bst.Root == nil {
        fmt.Println("tree is empty.")
    }
    fmt.Print("inorder traversal: ")
    traverseInOrder(bst.Root)
    fmt.Println("")
}

func (bst *BinarySearchTree) TraversePreOrder() {
    if bst.Root == nil {
        fmt.Println("tree is empty.")
    }
    fmt.Print("preorder traversal: ")
    traversePreOrder(bst.Root)
    fmt.Println("")
}

func (bst *BinarySearchTree) TraversePostOrder() {
    if bst.Root == nil {
        fmt.Println("tree is empty.")
    }
    fmt.Print("postorder traversal: ")
    traversePostOrder(bst.Root)
    fmt.Println(" ")
}

Test:

package main

import (
    bst "binary_search_tree"
)

func createTree(bst *bst.BinarySearchTree) {
    bst.Insert(27)
    bst.Insert(35)
    bst.Insert(14)
    bst.Insert(19)
    bst.Insert(42)
    bst.Insert(31)
    bst.Insert(10)
    bst.Insert(8)
    bst.Insert(74)
    bst.Insert(40)
    bst.Insert(23)
    bst.Insert(18)
}

func search(bst *bst.BinarySearchTree) {
    bst.Search(31)
    bst.Search(19)
    bst.Search(42)
    bst.Search(10)
    bst.Search(16)
    bst.Search(8)
    bst.Search(74)
    bst.Search(23)
    bst.Search(71)
}

func traverse(bst *bst.BinarySearchTree) {
    bst.TraverseInOrder()
    bst.TraversePreOrder()
    bst.TraversePostOrder()
}


func main() {
    bst := &bst.BinarySearchTree{}

    //           27
    //        /      
    //      14        35
    //     /        /  
    //   10   19   31    42
    //  /     /         / 
    // 8     18 23     40   74
    createTree(bst)
    search(bst)
    traverse(bst)
}

output:

Visiting elements 31, path: -> 27 -> 35 -> 31 found
Visiting elements 19, path: -> 27 -> 14 -> 19 found
Visiting elements 42, path: -> 27 -> 35 -> 42 found
Visiting elements 10, path: -> 27 -> 14 -> 10 found
Visiting elements 16, path: -> 27 -> 14 -> 19 -> 18 >> 16 not found
Visiting elements 8, path: -> 27 -> 14 -> 10 -> 8 found
Visiting elements 74, path: -> 27 -> 35 -> 42 -> 74 found
Visiting elements 23, path: -> 27 -> 14 -> 19 -> 23 found
Visiting elements 71, path: -> 27 -> 35 -> 42 -> 74 >> 71 not found
inorder traversal:  8 10 14 18 19 23 27 31 35 40 42 74
preorder traversal:  27 14 10 8 19 18 23 35 31 42 40 74
postorder traversal:  8 10 18 23 19 14 31 40 74 42 35 27