Moving trees to generics

Author: deepak-malik

src/com/deepak/data/structure/Tree/BinarySearchTree.java

@@ -10,38 +10,38 @@
  * 
  * @author Deepak
  */
-public class BinarySearchTree {
+public class BinarySearchTree<E extends Comparable<E>> {
 
 	/* We will maintain root and size of the tree.
 	 * Size here means number of nodes in the tree */
-	private Node root;
+	private Node<E> root;
 
 	/**
 	 * Add Node to the tree
 	 */
-	public void addNode(int value) {
+	public void addNode(E value) {
 		if (root == null) {
-			root = new Node(value);
+			root = new Node<E>(value);
 		} else {
 			addNode(root, value);
 		}
 	}
 
-	private Node addNode(Node root, int value) {
+	private Node<E> addNode(Node<E> root, E value) {
 		if (root == null) {
 			return null;
 		} 
-		if (value <= root.value) { /* We will insert left */
+		if ((root.value).compareTo(value) <= 0) { /* We will insert left */
 			if (root.left != null) {
 				addNode(root.left, value);
 			} else {
-				root.left = new Node(value);
+				root.left = new Node<E>(value);
 			}
 		} else { /* We will insert right */
 			if (root.right != null) {
 				addNode(root.right, value);
 			} else {
-				root.right = new Node(value);
+				root.right = new Node<E>(value);
 			}
 		}
 		return root;
@@ -51,7 +51,7 @@ public int size() {
 		return size(root);
 	}
 
-	private int size(Node root) {
+	private int size(Node<E> root) {
 		if (root == null) {
 			return 0;
 		}
@@ -62,22 +62,22 @@ public boolean isEmpty() {
 		return size() == 0;
 	}
 
-	public Node getRoot() {
+	public Node<E> getRoot() {
 		if (isEmpty()) {
 			return null;
 		}
 		return root;
 	}
 
-	public boolean isRoot(Node node) {
+	public boolean isRoot(Node<E> node) {
 		return node == root;
 	}
 
-	public Node findParent(Node node) {
+	public Node<E> findParent(Node<E> node) {
 		return findParent(node.value, root, null);
 	}
 
-	private Node findParent(int value, Node root, Node parent) {
+	private Node<E> findParent(E value, Node<E> root, Node<E> parent) {
 		if (root == null) {
 			return null;
 		}
@@ -90,37 +90,37 @@ private Node findParent(int value, Node root, Node parent) {
 		return parent;
 	}
 
-	public boolean hasParent(Node node) {
+	public boolean hasParent(Node<E> node) {
 		return findParent(node) != null;
 	}
 
-	public boolean hasLeftNode(Node node) {
+	public boolean hasLeftNode(Node<E> node) {
 		return node.left != null;
 	}
 
-	public boolean hasRightNode(Node node) {
+	public boolean hasRightNode(Node<E> node) {
 		return node.right != null;
 	}
 
-	public Node findLeft(Node node) {
+	public Node<E> findLeft(Node<E> node) {
 		if (hasLeftNode(node)) {
 			return node.left;
 		}
 		return null;
 	}
 
-	public Node findRight(Node node) {
+	public Node<E> findRight(Node<E> node) {
 		if (hasRightNode(node)) {
 			return node.right;
 		}
 		return null;
 	}
 
-	public boolean isLeafNode(Node node) {
+	public boolean isLeafNode(Node<E> node) {
 		return !hasLeftNode(node) && !hasRightNode(node);
 	}
 
-	public static int getDepth(Node node) {
+	public int getDepth(Node<E> node) {
 		if (node == null) {
 			return 0;
 		}
@@ -129,14 +129,14 @@ public static int getDepth(Node node) {
 		return left > right ? left + 1 : right + 1;
 	}
 
-	public boolean contains(int value) {
+	public boolean contains(E value) {
 		return search(value) != null;
 	}
 
-	public Node search(int value) {
-		Node node = root;
+	public Node<E> search(E value) {
+		Node<E> node = root;
 		while (node != null && node.value != value) {
-			if (value <= node.value) {
+			if (value.compareTo(node.value) <= 0) {
 				node = node.left;
 			} else {
 				node = node.right;
@@ -145,23 +145,23 @@ public Node search(int value) {
 		return node;
 	}
 
-	public Node delete(int value) {
+	public Node<E> delete(E value) {
 		return delete(root, value);
 	}
 
 	/* There are 3 cases here, 
 	 * 1. Node to be removed has no child
 	 * 2. Node to be removed has one child
 	 * 3. Node to be removed has two child */
-	private Node delete(Node root, int value) {
+	private Node<E> delete(Node<E> root, E value) {
 		/* Base case, when tree is empty */
 		if (root == null) {
 			return root;
 		}
 		/* Now, go down the tree */
-		if (value < root.value) {
+		if (value.compareTo(root.value) < 0) {
 			root.left = delete(root.left, value);
-		} else if (value > root.value) {
+		} else if (value.compareTo(root.value) > 0) {
 			root.right = delete(root.right, value);
 		} else { /* If key is same as the root key, this is the node to be deleted */
 			/* Node with only one child or no child */
@@ -170,7 +170,7 @@ private Node delete(Node root, int value) {
 			} else if (root.right == null) {
 				return root.left;
 			}
-			int minv = root.value;
+			E minv = root.value;
 	        while (root.left != null)
 	        {
 	            minv = root.left.value;
@@ -182,16 +182,16 @@ private Node delete(Node root, int value) {
 		return root;
 	}
 
-	public int getMinimum() {
-		Node node = root;
+	public E getMinimum() {
+		Node<E> node = root;
 		while (node.left != null) {
 			node = node.left;
 		}
 		return node.value;
 	}
 
-	public int getMaximum() {
-		Node node = root;
+	public E getMaximum() {
+		Node<E> node = root;
 		while (node.right != null) {
 			node = node.right;
 		}
@@ -200,7 +200,7 @@ public int getMaximum() {
 
 	/* All of these are DFS */
 	/* Left -> Root -> Right */
-	public void traverseInOrder(Node node) {
+	public void traverseInOrder(Node<E> node) {
 		if (node == null) {
 			return;
 		}
@@ -210,7 +210,7 @@ public void traverseInOrder(Node node) {
 	}
 
 	/* Root -> Left -> Right */
-	public void traversePreOrder(Node node) {
+	public void traversePreOrder(Node<E> node) {
 		if (node == null) {
 			return;
 		}
@@ -220,7 +220,7 @@ public void traversePreOrder(Node node) {
 	}
 
 	/* Left -> Root -> Right */
-	public void traversePostOrder(Node node) {
+	public void traversePostOrder(Node<E> node) {
 		if (node == null) {
 			return;
 		}
@@ -231,17 +231,17 @@ public void traversePostOrder(Node node) {
 
 	/* This is BFS */
 	/* Level by Level */
-	public void traverseLevelOrder(Node root) {
-		Queue<Node> firstQ = new LinkedList<>();
+	public void traverseLevelOrder(Node<E> root) {
+		Queue<Node<E>> firstQ = new LinkedList<>();
 		firstQ.add(root);
 
-		Queue<Queue<Node>> mainQ = new LinkedList<>();
+		Queue<Queue<Node<E>>> mainQ = new LinkedList<>();
 		mainQ.add(firstQ);
 
 		while (!mainQ.isEmpty()) {
-	        Queue<Node> levelQ = mainQ.remove();
-	        Queue<Node> nextLevelQ = new LinkedList<>();
-	        for (Node x : levelQ) {
+	        Queue<Node<E>> levelQ = mainQ.remove();
+	        Queue<Node<E>> nextLevelQ = new LinkedList<>();
+	        for (Node<E> x : levelQ) {
 	            System.out.print(x.value + " ");
 	            if (x.left != null)    nextLevelQ.add(x.left);
 	            if (x.right != null)   nextLevelQ.add(x.right);
@@ -256,13 +256,13 @@ public void traverseLevelOrder(Node root) {
 	 * 
 	 * @author Deepak
 	 */
-	public class Node {
+	public class Node<T> {
 
-		private Node left;
-		private Node right;
-		private int value;
+		private Node<T> left;
+		private Node<T> right;
+		private T value;
 
-		public Node(int value) {
+		public Node(T value) {
 			this.value = value;
 		}