Add implementation of BST tree

Author: sudheerj

README.md

@@ -136,7 +136,7 @@ List of Programs related to data structures and algorithms
 
 ### Tree
 
-   1. Maximum depth of binary tree: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/tree/maxDepthBinaryTree.js)
+   1. Maximum depth of binary tree: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/tree/1.maxDepthBinaryTree/maxDepthBinaryTree.js)
 
    2. Same tree: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/tree/sameTree.js)
 

src/images/bfs-traversal.png

@@ -0,0 +1,175 @@
+package java1.datastructures.tree.binarytree;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+class Node {
+    public Node left;
+    public Node right;
+    public int value;
+
+    Node(int value){
+        this.value = value;
+        this.left = null;
+        this.right = null;
+    }
+}
+public class BinarySearchTree {
+
+    private Node root;
+
+    BinarySearchTree(){
+        this.root = null;
+    }
+
+    public void insert(int value){
+        Node newNode = new Node(value);
+        if(this.root == null) {
+            this.root = newNode;
+            return;
+        }
+
+        Node currentNode = this.root;
+        while (true) {
+            if(value < currentNode.value) {
+                if(currentNode.left == null) {
+                    currentNode.left = newNode;
+                    return;
+                }
+                currentNode = currentNode.left;
+
+            } else if(value > currentNode.value) {
+                if(currentNode.right == null) {
+                    currentNode.right = newNode;
+                    return;
+                }
+                currentNode = currentNode.right;
+            } else {
+                return;
+            }
+        }
+    }
+
+    public boolean lookup(int value){
+        if(this.root == null) return false;
+
+        Node currentNode = this.root;
+
+        while (currentNode != null) {
+            if(value < currentNode.value) {
+                currentNode = currentNode.left;
+            } else if(value > currentNode.value) {
+                currentNode = currentNode.right;
+            } else {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public Node minValueNode(Node current){
+        while(true){
+            if(current.left == null) return current;
+            current = current.left;
+        }  
+    }
+
+    public Node maxValueNode(Node current){
+        while(true){
+            if(current.right == null) return current;
+            current = current.right;
+        }  
+    }
+
+    public void bfs(){
+        Node currentNode = this.root;
+        List<Integer> output = new ArrayList<>();
+        Queue<Node> queue = new LinkedList<>();
+        queue.add(currentNode);
+
+        while (queue.size() != 0) {
+            currentNode = queue.remove();
+            output.add(currentNode.value);
+            if(currentNode.left != null) queue.add(currentNode.left);
+            if(currentNode.right != null) queue.add(currentNode.right);
+        }
+
+        System.out.println(Arrays.deepToString(output.toArray()));
+    }
+
+    public void dfsPreOrder(){
+        List<Integer> output = new ArrayList<>();
+
+        class Traversal {
+            Traversal(Node currentNode){
+                output.add(currentNode.value);
+                if(currentNode.left != null) new Traversal(currentNode.left);
+                if(currentNode.right != null) new Traversal(currentNode.right);
+            }
+        }
+
+        new Traversal(root);
+        System.out.println(Arrays.deepToString(output.toArray()));
+    }
+
+    public void dfsPostOrder(){
+        List<Integer> output = new ArrayList<>();
+
+        class Traversal {
+            Traversal(Node currentNode) {
+                if(currentNode.left != null) new Traversal(currentNode.left);
+                if(currentNode.right != null) new Traversal(currentNode.right);
+                output.add(currentNode.value);
+            }
+        }
+
+        new Traversal(root);
+        System.out.println(Arrays.deepToString(output.toArray()));
+    }
+
+    public void dfsInOrder(){
+        List<Integer> output = new ArrayList<>();
+
+        class Traversal {
+            Traversal(Node currentNode) {
+                if(currentNode.left != null) new Traversal(currentNode.left);
+                output.add(currentNode.value);
+                if(currentNode.right != null) new Traversal(currentNode.right);
+            }
+        }
+
+        new Traversal(root);
+        System.out.println(Arrays.deepToString(output.toArray()));
+    }
+
+    public static void main(String[] args) {
+        BinarySearchTree tree = new BinarySearchTree();
+        tree.insert(20);
+        tree.insert(15);
+        tree.insert(25);
+        tree.insert(12);
+        tree.insert(16);
+        tree.insert(22);
+        tree.insert(30);
+        tree.insert(10);
+        tree.insert(14);
+        tree.insert(28);
+        tree.insert(35);
+
+        System.out.println(tree.lookup(25));
+        System.out.println(tree.lookup(7));
+        System.out.println(tree.lookup(10));
+        System.out.println(tree.lookup(12));
+        System.out.println(tree.minValueNode(tree.root.left).value);
+        System.out.println(tree.maxValueNode(tree.root.right).value);
+
+        tree.bfs();
+        tree.dfsPreOrder();
+        tree.dfsPostOrder();
+        tree.dfsInOrder();
+    }
+}

src/images/bst.png

@@ -0,0 +1,58 @@
+A Binary Search Tree (BST) is a binary tree where every node in the left subtree is less than the root, and every node in the right subtree is of a value greater than the root. This datastructure is mainly used for operations like search, delete, and insert. These operations are fast and efficient without shifting values in memory.
+
+**Note:** Each left and right subtrees must also be Binary Search Tree.
+
+### Types of BSTs:
+
+1. **Full Binary Search Tree:**  Each node will have either 0 or 2 children
+2. **Complete Binary Search Tree:** All the levels of the tree are filled completely except possibly the lowest level nodes which are filled from the left.
+3. **Perfect Binary Search Tree:** It is both full and complete BST. In which, all the leaf nodes are at the same depth, and all non-leaf nodes have two children.
+
+The structure of binary search tree looks like below,
+
+   ![Screenshot](../../../images/bst.png)
+
+The tree can have the following functionalities,
+
+1. **Insert:** This method is used to insert a new node inside BST based on node's value. If the root node is null, update the root node with newnode and return the tree. Otherwise, you need to traverse the tree using a loop and insert the new node based on its value. i.e, First, assign the root node as current node. If the node value is less than current node, the node needs to be inserted on left subtree. Otherwise, the new node needs to be inserted on right subtree. The iteration continues until the node is inserted or already exists.
+   
+2. **Lookup:** The lookup method finds a node in tree. If the root is null, just return false. Otherwise traverse the tree starting from root node. If the given value is less than current node' value, the left subtree needs to traversed. If not, the right subtree needs to be traversed to find the value. In case, the value is equal to particular node value, return true to indicate that the value exists.
+   
+3. **Min value node**: The minimum value of a particular tree is identified on left subtree. If the left node doesn't exists, the current value will become the minimum value node.
+   
+4. **Max value node**: The maximum value of a particular tree is identified on right subtree. If the right node doesn't exists, the current value will become the maximum value node.
+   
+5. **BFS traversal:** BSF begins with a particular node, and then first traverses all its adjacent. Once all adjacent are visited, then their adjacent are traversed. i.e, It visits the nodes level by level. 
+
+   ![Screenshot](../../../images/bfs-traversal.png)
+   
+    The BFS traversal is implemented in the below step by step manner.
+   
+   1. Initially, the current node(`current`) is set to the root of the binary tree to indicate the starting point of the traversal.
+
+   2. An empty array `output` is initialized to store the node values in the order they are visited.
+
+   3. An empty array `queue` is initialized to perform the breadth-first traversal of the tree. The root node is added to the queue.
+
+   4. Iterate using a while loop until there are nodes in the queue. For each iteration,
+   
+        1. Remove the first node from the queue and assign it to `currentNode`.
+        2. Add the currentNode value to the `output` array.
+        3. If the currentNode has a left child, add it to the queue.
+        4.  If the currentNode has a right child, add it to the queue.
+
+    5. Once the while loop is completed, all nodes in the binary tree have been visited. Return `output` array containing the node values in breadth-first order.
+   
+6. **DFS traversal:** It begins at the root node and then it explores each branch before backtracking. This is implemented using stacks and recursion stacks helpful to backtrack.
+
+   i. **PreOrder** In pre-order traversal of a binary tree, first traverse the root node, then the left subtree and then finally the right subtree.
+
+   ![Screenshot](../../../images/dfs-preorder.png)
+
+   ii. **PostOrder** In post-order traversal of a binary tree, first traverses the left subtree, then the right subtree and then finally the root node.
+
+   ![Screenshot](../../../images/dfs-postorder.png)
+
+   iii. **InOrder** In-order traversal of a binary tree, first traverses the left subtree, then the root node and finally the right subtree.
+
+   ![Screenshot](../../../images/dfs-inorder.png)

src/images/dfs-inorder.png

@@ -26,7 +26,7 @@ class BinarySearchTree {
                         return this;
                     }
                     currentNode = currentNode.left
-                } else if (value > currentNode.right){
+                } else if (value > currentNode.value){
                     // Right
                     if(currentNode.right === null) {
                         currentNode.right = newNode;
@@ -38,34 +38,22 @@ class BinarySearchTree {
                 }
             }
     }
+
     lookup(value) {
         if(this.root === null) {
             return false;
         }
         let currentNode = this.root;
-        while(true) {
-            if(value < currentNode.left) {
+        while(currentNode) {
+            if(value < currentNode.value) {
                 currentNode = currentNode.left;
-            } else if(value > currentNode.right) {
+            } else if(value > currentNode.value) {
                 currentNode = currentNode.right;
             } else {
                 return true;
             }
         }
-    }
 
-    contains(value) {
-        if (this.root === null) return false;
-        let temp = this.root;
-        while (temp) {
-            if (value < temp.value) {
-                temp = temp.left;
-            } else if (value > temp.value) {
-                temp = temp.right;
-            } else {
-                return true;
-            }
-        }
         return false;
     }
 
@@ -83,7 +71,7 @@ class BinarySearchTree {
         }
     }
 
-    BFS() {
+    bfs() {
         let currentNode = this.root;
         let queue = [];
         let output = [];
@@ -98,7 +86,7 @@ class BinarySearchTree {
         return output;
     }
 
-    DFSPreOrder() {
+    dfsPreOrder() {
         let output = [];
         function traverse(currentNode) {
             output.push(currentNode.value);
@@ -109,7 +97,7 @@ class BinarySearchTree {
         return output;
     }
 
-    DFSPostOrder() {
+    dfsPostOrder() {
         let output = [];
         function traverse(currentNode) {
             if(currentNode.left) traverse(currentNode.left);
@@ -120,7 +108,7 @@ class BinarySearchTree {
         return output;
     }
 
-    DFSInOrder() {
+    dfsInOrder() {
         let output = [];
         function traverse(currentNode) {
             if(currentNode.left) traverse(currentNode.left);
@@ -133,19 +121,27 @@ class BinarySearchTree {
 }
 
 const tree = new BinarySearchTree();
-tree.insert(80);
-tree.insert(100);
-tree.insert(50);
-console.log(tree.lookup(50));
-tree.insert(90);
-console.log(tree.lookup(88));
-console.log(tree.contains(100));
-console.log(tree.contains(9));
+tree.insert(20);
+tree.insert(15);
+tree.insert(25);
+tree.insert(12);
+tree.insert(16);
+tree.insert(22);
+tree.insert(30);
+tree.insert(10);
+tree.insert(14);
+tree.insert(28);
+tree.insert(35);
+console.dir(tree, {depth: null});
+
+console.log(tree.lookup(25));
+console.log(tree.lookup(7));
+console.log(tree.lookup(10));
+console.log(tree.lookup(12));
 console.log(tree.minValueNode(tree.root.left));
 console.log(tree.maxValueNode(tree.root.right));
-tree.insert(12);
-tree.insert(67);
-console.log(tree.BFS());
-console.log(tree.DFSPreOrder());
-console.log(tree.DFSPostOrder());
-console.log(tree.DFSInOrder());
+
+console.log(tree.bfs());
+console.log(tree.dfsPreOrder());
+console.log(tree.dfsPostOrder());
+console.log(tree.dfsInOrder());