build tree from inorder and preorder

Author: xiaoningning

PuzzleCoding/src/BuildBT.java

@@ -0,0 +1,56 @@
+import java.util.Arrays;
+import java.util.HashMap;
+
+/**
+ * Given preorder and inorder traversal of a tree, construct the binary tree.
+ * in-order: left, root, right
+ * pre-order: root, left, right
+ * <p/>
+ * <p/>
+ * ________ 7______
+ * /                  \
+ * __10__             ___2
+ * /      \           /
+ * 4       3        _8
+ *          \     /
+ *          1   11
+ * preorder = {7,10,4,3,1,2,8,11}
+ * inorder = {4,10,3,1,7,11,8,2}
+ */
+public class BuildBT {
+    public static void main(String[] args) {
+        int[] preorder = new int[]{7, 10, 4, 3, 1, 2, 8, 11};
+        int[] inorder = new int[]{4, 10, 3, 1, 7, 11, 8, 2};
+
+        // build b tree
+        Node bt = buildBTInorderPreorder(inorder, preorder);
+        bt.printBT();
+    }
+
+    public static HashMap<Integer, Integer> mapIndex(int[] inorder) {
+        HashMap<Integer, Integer> index = new HashMap<Integer, Integer>();
+        for (int i = 0; i < inorder.length; i++) {
+            index.put(inorder[i], i);
+        }
+        return index;
+    }
+
+    public static Node buildBTInorderPreorder(int[] in,
+                                              int[] pre) {
+        if (in.length == 0 || pre.length != in.length)
+            return null;
+
+        HashMap<Integer, Integer> index = new HashMap<Integer, Integer>();
+        for (int i = 0; i < in.length; i++) {
+            index.put(in[i], i);
+        }
+
+        Node root = new Node(pre[0]);
+        int rootIndex = index.get(pre[0]);
+        root.left = buildBTInorderPreorder(Arrays.copyOfRange(in, 0, rootIndex),
+                Arrays.copyOfRange(pre, 1, rootIndex+1));
+        root.right = buildBTInorderPreorder(Arrays.copyOfRange(in, rootIndex + 1, in.length),
+                Arrays.copyOfRange(pre, rootIndex+1, pre.length));
+        return root;
+    }
+}

PuzzleCoding/src/Node.java

@@ -1,3 +1,6 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
 /**
  * a node class for tree
  */
@@ -40,4 +43,29 @@ public int size() {
         }
         return size + 1;
     }
+
+    public void printBT(){
+        Queue<Node> current = new LinkedList<Node>();
+        Queue<Node> next = new LinkedList<Node>();
+
+        current.add(this);
+        System.out.println(this.value);
+        while (!current.isEmpty()){
+            Node n = current.poll();
+            if(n.left != null){
+                System.out.print(n.left.value + " ");
+                next.add(n.left);
+            }
+            if(n.right != null){
+                System.out.print(n.right.value + " ");
+                next.add(n.right);
+            }
+            if(current.isEmpty()){
+                current.addAll(next);
+                next.clear();
+                System.out.println();
+            }
+        }
+
+    }
 }