Implement BST

src/Test/IntSetBSTTest.java

@@ -0,0 +1,56 @@
+package devSet;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Random;
+
+import org.junit.jupiter.api.Test;
+
+class IntSetBSTTest {
+
+	IntSetBST bst = new IntSetBST();
+	private static int MAX_VAL = 1000000;
+	private static int MAX_ELE = MAX_VAL/100;
+	private static Random num = new Random();
+
+	@Test
+	void testIntSetImp() {
+		bst.intSetImp(MAX_ELE, MAX_VAL);
+		assertEquals(MAX_VAL, bst.maxval);
+		assertEquals(MAX_ELE, bst.maxelems);
+	}
+
+	@Test
+	void testInsert() {
+
+		bst.intSetImp(MAX_ELE, MAX_VAL);
+
+		int x =0;
+		for(int i=0;i<MAX_ELE;i++)
+		{
+			bst.insert(x++);
+		}
+		System.out.println("bst size: " + bst.size());
+		assertEquals(bst.size(), MAX_ELE);
+	}
+
+	@Test
+	void testReport() {
+		bst.intSetImp(MAX_ELE, MAX_VAL);
+		for(int i=0;i<MAX_ELE;i++)
+		{
+			bst.insert(num.nextInt(MAX_ELE));
+		}
+		bst.report();
+
+		for(int i=0;i<MAX_ELE;i++) {
+			assertEquals(bst.size(), bst.bst.getSize());
+		}
+	}
+
+
+	@Test
+	void testSize() {
+		bst.size();
+	}
+}

src/devSet/BinarySearchTree.java

@@ -0,0 +1,67 @@
+package devSet;
+
+import java.util.ArrayList;
+
+public class BinarySearchTree {
+    private TreeNode root = new TreeNode();
+    private int size = 0;
+
+    public TreeNode insertKey(TreeNode root, int x) {
+        TreeNode p = root;
+        TreeNode newNode = new TreeNode(x);
+        this.size++;
+
+        if(p==null){
+        	this.size--;
+            return newNode;
+        }
+        else if(p.data>newNode.data){
+            p.left = insertKey(p.left, x);
+            return p;
+        }
+        else if(p.data<newNode.data){
+            p.right = insertKey(p.right, x);
+            return p;
+        }
+        else{ 
+            return p;
+        }
+    }
+
+    public int getSize() {
+    	return this.size;
+    }
+
+    public void insertBST(int x){
+        root = insertKey(root, x);
+    }
+
+    public TreeNode searchBST(int x){
+        TreeNode p = root;
+        while(p!=null){
+            if(x<p.data) p = p.left;
+            else if(x>p.data) p = p.right;
+            else return p;
+        }
+        return p;
+    }
+
+    public void inorder(TreeNode root, ArrayList<Integer> arr){
+        if(this.root!=null){
+            inorder(root.left, arr);
+            arr.add(root.data);
+            inorder(root.right, arr);
+        }
+    }
+
+    public int[] inorder() {
+    	int[] result = new int[this.size];
+    	ArrayList<Integer> list = new ArrayList<Integer>();
+    	this.inorder(this.root, list);
+
+    	for(int i=0; i<list.size(); i++) {
+    		result[i] = list.get(i);
+    	}
+    	return result;
+    }
+}

src/devSet/IntSetBST.java

@@ -1 +1,41 @@
+package devSet;
 
+public class IntSetBST implements IntSet{
+
+	BinarySearchTree bst;
+	private int maxval;
+	private int maxelems;
+
+	@Override
+	public void intSetImp(int maxelems, int maxval) {
+		// TODO Auto-generated method stub
+		bst = new BinarySearchTree();
+		this.maxval = maxval;
+		this.maxelems = maxelems;
+	}
+
+	@Override
+	public void insert(int element) {
+		// TODO Auto-generated method stub
+		if(bst.getSize() > maxelems) {
+			return ;
+		}
+		else if(element > maxval) {
+			return ;
+		}
+		bst.insertBST(element);
+	}
+
+	@Override
+	public int size() {
+		// TODO Auto-generated method stub
+		return bst.getSize();
+	}
+
+	@Override
+	public int[] report() {
+		// TODO Auto-generated method stub
+		return bst.inorder();
+	}
+
+}

src/devSet/TreeNode.java

@@ -0,0 +1,22 @@
+package devSet;
+
+public class TreeNode {
+    int data;
+    TreeNode left;
+    TreeNode right;
+
+    public TreeNode(){
+        this.left = null;
+        this.right = null;
+    }
+
+    public TreeNode(int x){
+        this.data = x;
+        this.left = null;
+        this.right = null;
+    }
+
+    public Object getData(){
+        return data;
+    }
+}