code refactoring

Author: Ram swaroop

src/me/ramswaroop/common/BinaryTree.java

@@ -4,10 +4,11 @@
 
 /**
  * Created by IntelliJ IDEA.
- * User: ramswaroop
- * Date: 4/19/15
- * Time: 6:35 PM
- * To change this template go to Preferences | IDE Settings | File and Code Templates
+ *
+ * @author: ramswaroop
+ * @date: 4/19/15
+ * @time: 6:35 PM
+ * @see: https://www.cs.bu.edu/teaching/c/tree/breadth-first/
  */
 public class BinaryTree<E extends Comparable<E>> extends Tree<E> {
 
@@ -151,7 +152,7 @@ public void delete(E value) {
      *
      * @param node
      */
-    public void deleteChildrens(BinaryNode<E> node) {
+    public void deleteChildren(BinaryNode<E> node) {
         if (node == null) {
             return;
         }
@@ -238,9 +239,10 @@ public int width(BinaryNode<E> node, int width) {
 
         if (node.left == null && node.right == null) return 1; // for single/leaf node
 
-        int level_width = width(node.left, width) + width(node.right, width);
+        int levelWidth = width(node.left, width) + width(node.right, width);
 
-        if (level_width > width) width = level_width;
+        // to find max width
+        if (levelWidth > width) width = levelWidth;
 
         return width;
     }
@@ -250,4 +252,15 @@ public void printValue(BinaryNode<E> node) {
 
         out.print(node.value);
     }
+
+    // test cases
+    public static void main(String[] a) {
+        BinaryTree<Integer> bt = new BinaryTree<>();
+        bt.put(1);
+        bt.put(2);
+        bt.put(3);
+        bt.put(4);
+        bt.put(5);
+        bt.breadthFirstTraversal();
+    }
 }

src/me/ramswaroop/trees/CheckForBST.java

@@ -1,6 +1,7 @@
 package me.ramswaroop.trees;
 
 import me.ramswaroop.common.BinaryNode;
+import me.ramswaroop.common.BinarySearchTree;
 import me.ramswaroop.common.BinaryTree;
 
 import java.util.List;
@@ -13,22 +14,11 @@
  * @author: ramswaroop
  * @date: 6/26/15
  * @time: 7:14 PM
+ * 
+ * Concept: Perform in-order traversal of the tree and if
+ * the result isn't in ascending order then returns false.
  */
-public class CheckForBST<E extends Comparable<E>> extends BinaryTree<E> {
-
-    /**
-     * Checks whether the binary tree is a BST or not.
-     * <p/>
-     * Approach: Performs in-order traversal of the tree and if
-     * the result isn't in ascending order then returns false.
-     *
-     * @return
-     */
-    public boolean isBST() {
-        //List<BinaryNode<E>> list = new ArrayList<>();
-        BinaryNode<E> prev = new BinaryNode<>(null);
-        return isBST(root, prev);
-    }
+public class CheckForBST {
 
     /**
      * Traverse the tree in in-order fashion and insert all nodes
@@ -38,7 +28,7 @@ public boolean isBST() {
      * @param list
      * @return
      */
-    public boolean isBST(BinaryNode<E> node, List<BinaryNode<E>> list) {
+    public static <E extends Comparable<E>> boolean isBST(BinaryNode<E> node, List<BinaryNode<E>> list) {
         if (node == null) return true;
 
         boolean left = isBST(node.left, list);
@@ -62,7 +52,7 @@ public boolean isBST(BinaryNode<E> node, List<BinaryNode<E>> list) {
      * @param prev
      * @return
      */
-    public boolean isBST(BinaryNode<E> node, BinaryNode<E> prev) {
+    public static <E extends Comparable<E>> boolean isBST(BinaryNode<E> node, BinaryNode<E> prev) {
         if (node == null) return true;
 
         boolean left = isBST(node.left, prev);
@@ -79,14 +69,23 @@ public boolean isBST(BinaryNode<E> node, BinaryNode<E> prev) {
     }
 
     public static void main(String a[]) {
-        CheckForBST<Integer> bt = new CheckForBST<>();
-        bt.put(6);
-        bt.put(3);
-        bt.put(5);
-        bt.put(7);
-        bt.put(8);
-        bt.put(9);
+        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
+        binarySearchTree.put(6);
+        binarySearchTree.put(3);
+        binarySearchTree.put(5);
+        binarySearchTree.put(7);
+        binarySearchTree.put(8);
+        binarySearchTree.put(9);
+        out.println("Is BST: ");
+        out.println(isBST(binarySearchTree.root, new BinaryNode<Integer>(null)));
+        BinaryTree<Integer> binaryTree = new BinaryTree<>();
+        binaryTree.put(6);
+        binaryTree.put(3);
+        binaryTree.put(5);
+        binaryTree.put(7);
+        binaryTree.put(8);
+        binaryTree.put(9);
         out.println("Is BST: ");
-        out.println(bt.isBST());
+        out.println(isBST(binaryTree.root, new BinaryNode<Integer>(null)));
     }
 }