Add BST - Binary Search Tree

Author: bcExpt1123

src/main/java/org/alda/Main.java

@@ -19,10 +19,11 @@
 import org.alda.structure.stack.array.StackArray;
 import org.alda.structure.stack.linkedList.IStackLinkedList;
 import org.alda.structure.stack.linkedList.StackLinkedList;
+import org.alda.structure.tree.bst.BinarySearchTree;
 
 public class Main {
     public static void main(String[] args) {
-        testPriorityQueue();
+        testBST();
     }
     public static void testSimpleLinkedList() {
         ISimpleLinkedList<Integer> intList = new SimpleLinkedList<Integer>();
@@ -206,4 +207,17 @@ public static void testPriorityQueue(){
         System.out.println(item2);
         System.out.println(item3);
     }
+
+    public static void testBST(){
+        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
+        bst.insert(5);
+        bst.insert(3);
+        bst.insert(7);
+        bst.insert(1);
+        bst.insert(20);
+        bst.insert(4);
+
+        System.out.println(bst.inorderTraversal());
+        System.out.println(bst.search(4));
+    }
 }

src/main/java/org/alda/structure/tree/bst/BinarySearchTree.java

@@ -0,0 +1,57 @@
+package org.alda.structure.tree.bst;
+
+import org.alda.common.Comparer;
+
+import java.util.ArrayList;
+
+public class BinarySearchTree<T extends Comparable<T>> {
+    Node<T> root;
+
+    public BinarySearchTree() {
+        root = null;
+    }
+
+    public void insert(T key) {
+        root = _insertRecursive(root, key);
+    }
+
+    protected Node<T> _insertRecursive(Node<T> root, T key){
+        if (root == null) {
+            return new Node<>(key);
+        }
+        if (key.compareTo(root.key) < 0) {
+            root.left = _insertRecursive(root.left, key);
+        } else if (key.compareTo(root.key) > 0) {
+            root.right = _insertRecursive(root.right, key);
+        }
+        return root;
+    }
+
+    public Node<T> search(T key) {
+        return _searchRecursive(root, key);
+    }
+
+    protected Node<T> _searchRecursive(Node<T> root, T key){
+        if (root == null || root.key.equals(key)) {
+            return root;
+        }
+        if (key.compareTo(root.key) < 0) {
+            return _searchRecursive(root.left, key);
+        }
+        return _searchRecursive(root.right, key);
+    }
+
+    public ArrayList<T> inorderTraversal() {
+        ArrayList<T> result = new ArrayList<>();
+        _inorderTraversal(root, result);
+        return result;
+    }
+
+    protected void _inorderTraversal(Node<T> root, ArrayList<T> result) {
+        if (root != null) {
+            _inorderTraversal(root.left, result);
+            result.add(root.key);
+            _inorderTraversal(root.right, result);
+        }
+    }
+}

src/main/java/org/alda/structure/tree/bst/Node.java

@@ -0,0 +1,16 @@
+package org.alda.structure.tree.bst;
+
+/**
+ * Node for binary search tree
+ * @param <T>
+ */
+public class Node<T> {
+    T key;
+    Node<T> left;
+    Node<T> right;
+    public Node(T key){
+        this.key = key;
+        left = null;
+        right = null;
+    }
+}