code refactoring

Author: Ram swaroop

src/me/ramswaroop/common/BinaryTree.java

@@ -106,28 +106,28 @@ public void postOrder(BinaryNode<E> node) {
      * DEF: Breadth-first search (BFS) is an algorithm for traversing or searching tree
      * or graph data structures. It starts at the tree root (or some arbitrary node of a
      * graph, sometimes referred to as a `search key'[1]) and explores the neighbor nodes
-     * first, before moving to the next level neighbors.
+     * first, before moving to the next level neighbors. See {@link me.ramswaroop.trees.BFSUsingQueue}
+     * for a O(n) solution.
+     * 
+     * Time complexity: O(n^2)
      */
     public void breadthFirstTraversal() {
         // assuming level starts at zero
-        breadthFirstTraversal(root, 0);
+        for (int level = 0; level < height(root); level++) {
+            printLevel(root, level);
+        }
     }
 
-    // todo need to correct, failing in some cases
-    public void breadthFirstTraversal(BinaryNode<E> node, int level) {
+    public void printLevel(BinaryNode<E> node, int level) {
         if (node == null) return;
 
         // print the starting node
-        if (level == 0) printValue(node);
-
-        // print the neighbour nodes
-        printValue(node.left);
-        printValue(node.right);
-
-        // go to next level
-        level++;
-        breadthFirstTraversal(node.left, level);
-        breadthFirstTraversal(node.right, level);
+        if (level == 0) {
+            printValue(node);
+        } else { // print the neighbour nodes            
+            printLevel(node.left, level - 1);
+            printLevel(node.right, level - 1);
+        }
     }
 
     /**
@@ -261,6 +261,11 @@ public static void main(String[] a) {
         bt.put(3);
         bt.put(4);
         bt.put(5);
+        bt.put(6);
+        bt.put(7);
+        bt.put(8);
         bt.breadthFirstTraversal();
+        out.println();
+        bt.inOrder();
     }
 }

src/me/ramswaroop/trees/MirrorTree.java

@@ -10,7 +10,7 @@
  * @date: 6/26/15
  * @time: 7:03 PM
  */
-public class MirrorTree<E extends Comparable<E>> extends BinaryTree<E> {
+public class MirrorTree {
 
     /**
      * Converts a Tree to its Mirror Tree.
@@ -21,27 +21,22 @@ public class MirrorTree<E extends Comparable<E>> extends BinaryTree<E> {
      * TIP: In-order traversal of mirror tree is exactly the
      * reverse of the in-order traversal of the original tree.
      */
-    public void mirror() {
-        mirror(root);
-    }
-
-    public void mirror(BinaryNode<E> node) {
+    public static <E extends Comparable<E>> void mirror(BinaryNode<E> node) {
         if (node == null) return;
 
-        BinaryNode<E> tempNode;
-
         // mirror sub-trees
         mirror(node.left);
         mirror(node.right);
 
         // swap nodes
+        BinaryNode<E> tempNode;
         tempNode = node.left;
         node.left = node.right;
         node.right = tempNode;
     }
 
     public static void main(String a[]) {
-        MirrorTree<Integer> bt = new MirrorTree<>();
+        BinaryTree<Integer> bt = new BinaryTree<>();
         bt.put(6);
         bt.put(3);
         bt.put(5);
@@ -51,7 +46,7 @@ public static void main(String a[]) {
         System.out.println("Original Tree");
         bt.breadthFirstTraversal();
         System.out.println("\nMirror Tree");
-        bt.mirror();
+        mirror(bt.root);
         bt.breadthFirstTraversal();
     }
 }

src/me/ramswaroop/trees/RootToLeafPaths.java

@@ -93,7 +93,7 @@ public boolean rootToLeafPathsSum(BinaryNode<E> node, List<E> pathList, int path
 
         if (node != null) pathList.add(node.value);
 
-        // if its either a leaf node or null then path is complete, add all in the list
+        // if its either a leaf node or null then path is complete, add all elements present in list
         if (node == null || (node.left == null && node.right == null)) {
             for (int i = 0; i < pathList.size(); i++) {
                 sum += Integer.parseInt(pathList.get(i).toString());