Adding BST Trees

Author: bhavnavarshney

Go/hashing/hashmap_impl.go renamed to Go/hashing/hashmapExecution.go

@@ -3,6 +3,7 @@ package hashing
 import "fmt"
 
 func TestHashing() {
+	fmt.Println("\n******** HASHING *********")
 	hashmap, err := createHashMap(5)
 	if err != nil {
 		fmt.Printf("Error in creating hashmap. Error:%v", err)

Go/linkedlist/linkedListExecution.go

@@ -0,0 +1,38 @@
+package linkedlist
+
+import (
+	"fmt"
+)
+
+func TestSinglyLinkedList() {
+	fmt.Println("***** Singly LinkedList *****")
+	l := SinglyLinkedList{}
+	l.InsertAtEnd(5)
+	l.InsertAtStart(100)
+	l.InsertAtEnd(200)
+	l.InsertAtIndex(1, 3)
+	l.Print()            // 100 3 5 200
+	l.DeleteAtIndex(2)   // 100 3 200
+	l.DeleteAtStart()    // 3 200
+	l.InsertAtStart(100) // 100 3 200
+	l.DeleteAtEnd()      // 100 3
+	l.Print()
+}
+
+func TestDoublyLinkedList() {
+	fmt.Println("\n***** Doubly LinkedList *******")
+	l2 := DoublyLinkedList{}
+	l2.InsertAtEnd(5)     //5
+	l2.InsertAtStart(100) //100 5
+	l2.Print("Insertion at Start & End")
+	l2.InsertAtEnd(200) // 100 5 200
+	l2.Print("Insertion at End")
+	l2.DeleteAtStart()      // 5 200
+	l2.InsertAtIndex(1, 10) // 5 10 200
+	l2.Print("Deletion at Start and Insert at Index")
+	l2.DeleteAtEnd()
+	l2.Print("Delete at End") // 5 10
+	l2.DeleteAtIndex(1)
+	l2.Print("Delete at Index 1") // 5
+
+}

Go/main.go

@@ -5,38 +5,31 @@ import (
 
 	"github.com/bhavnavarshney/Algorithms-and-Data-Structures/Go/hashing"
 	"github.com/bhavnavarshney/Algorithms-and-Data-Structures/Go/linkedlist"
+	"github.com/bhavnavarshney/Algorithms-and-Data-Structures/Go/trees"
 )
 
 func main() {
-	fmt.Println("***** Singly LinkedList *****")
-	l := linkedlist.SinglyLinkedList{}
-	l.InsertAtEnd(5)
-	l.InsertAtStart(100)
-	l.InsertAtEnd(200)
-	l.InsertAtIndex(1, 3)
-	l.Print()            // 100 3 5 200
-	l.DeleteAtIndex(2)   // 100 3 200
-	l.DeleteAtStart()    // 3 200
-	l.InsertAtStart(100) // 100 3 200
-	l.DeleteAtEnd()      // 100 3
-	l.Print()
-
-	fmt.Println("\n***** Doubly LinkedList *******")
-	l2 := linkedlist.DoublyLinkedList{}
-	l2.InsertAtEnd(5)     //5
-	l2.InsertAtStart(100) //100 5
-	l2.Print("Insertion at Start & End")
-	l2.InsertAtEnd(200) // 100 5 200
-	l2.Print("Insertion at End")
-	l2.DeleteAtStart()      // 5 200
-	l2.InsertAtIndex(1, 10) // 5 10 200
-	l2.Print("Deletion at Start and Insert at Index")
-	l2.DeleteAtEnd()
-	l2.Print("Delete at End") // 5 10
-	l2.DeleteAtIndex(1)
-	l2.Print("Delete at Index 1") // 5
-
-	fmt.Println("\n******** HASHING *********")
-	hashing.TestHashing()
+	var ch int
+	for {
+		fmt.Println("\n0: Exit 1. SinglyLinkedList 2: DoublyLinkedList 3. HashMap 4. BinarySearchTree")
+		fmt.Scanf("%d", &ch)
+		if ch == 0 {
+			return
+		}
+		switch ch {
+		case 1:
+			linkedlist.TestSinglyLinkedList()
+			break
+		case 2:
+			linkedlist.TestDoublyLinkedList()
+			break
+		case 3:
+			hashing.TestHashing()
+			break
+		case 4:
+			trees.TestBSTExecution()
+			break
+		}
+	}
 
 }

Go/trees/bst.go

@@ -0,0 +1,109 @@
+package trees
+
+import "fmt"
+
+// Node : Holds individual node
+type Node struct {
+	left  *Node
+	right *Node
+	data  int
+}
+
+// BST : Holds the Tree
+type BST struct {
+	root *Node
+}
+
+// NewBSTTree : Gives new BST Tree
+func NewBSTTree() *BST {
+	return &BST{
+		root: nil,
+	}
+}
+
+func (b *BST) insert(key int) {
+	newNode := &Node{data: key}
+	if b.root == nil {
+		b.root = newNode
+		return
+	}
+
+	_ = insertNode(b.root, key)
+}
+
+func insertNode(root *Node, key int) *Node {
+	if root == nil {
+		return &Node{data: key}
+	}
+	if key < root.data {
+		root.left = insertNode(root.left, key)
+	} else {
+		root.right = insertNode(root.right, key)
+	}
+	return root
+}
+
+func printInorder(root *Node) {
+	if root != nil {
+		printInorder(root.left)
+		fmt.Print(root.data, "->")
+		printInorder(root.right)
+	}
+}
+
+func search(root *Node, key int) bool {
+	if root == nil {
+		return false
+	}
+	if root.data == key {
+		return true
+	}
+	if key < root.data {
+		search(root.left, key)
+	}
+	return search(root.right, key)
+}
+
+func delete(root *Node, key int) (bool, *Node) {
+	var found bool
+	if root == nil {
+		return false, nil
+	}
+	if root.data == key {
+		if root.left == nil && root.right == nil {
+			return true, nil
+		}
+		if root.left != nil && root.right == nil {
+			return true, root.left
+		}
+		if root.right != nil && root.left == nil {
+			return true, root.right
+		}
+		if root.right != nil && root.left != nil {
+			successor := getInorderSuccessor(root.right)
+			root.data = successor.data
+			_, root.right = delete(root.right, root.data)
+			return true, root
+		}
+	}
+
+	if key < root.data {
+		found, root.left = delete(root.left, key)
+		if found {
+			return found, root
+		}
+	} else {
+		found, root.right = delete(root.right, key)
+		if found {
+			return found, root
+		}
+	}
+	return false, root
+}
+
+func getInorderSuccessor(root *Node) *Node {
+	for root != nil && root.left != nil {
+		root = root.left
+	}
+	return root
+}

Go/trees/treesExecution.go

@@ -0,0 +1,27 @@
+package trees
+
+import "fmt"
+
+// TestBSTExecution : testing all the functions of BST
+func TestBSTExecution() {
+	fmt.Println("\n ************ Binary Search Tree *************")
+	tree := NewBSTTree()
+	tree.insert(5)
+	tree.insert(10)
+	tree.insert(20)
+	tree.insert(2)
+	printInorder(tree.root) //2 5 10 20
+	fmt.Println("Found 100:", search(tree.root, 100))
+	fmt.Println("Found 20: ", search(tree.root, 20))
+	found, _ := delete(tree.root, 100)
+	fmt.Println("\nDeleted 100:", found)
+	printInorder(tree.root) //2 5 10 20
+	found, _ = delete(tree.root, 5)
+	fmt.Println("\nDeleted 5:", found)
+	printInorder(tree.root) //2 10 20
+	tree.insert(9)
+	found, _ = delete(tree.root, 9)
+	fmt.Println("\nDeleted 9:", found)
+	printInorder(tree.root) //2 5 10 20
+
+}