add 106

fishercoder1534 · fishercoder1534 · commit 35a0f61d237a · 2017-05-12T08:26:50.000-07:00
diff --git a/README.md b/README.md
@@ -334,6 +334,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |109|[Convert Sorted List to Binary Search Tree](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/)|[Solution](../master/src/main/java/com/stevesun/solutions/ConvertSortedListtoBinarySearchTree.java)| O(n)|O(h) | Medium | DFS, Recursion
 |108|[Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/)|[Solution](../master/src/main/java/com/stevesun/solutions/ConvertSortedArraytoBinarySearchTree.java)| O(n)|O(h) | Medium| Tree
 |107|[Binary Tree Level Order Traversal II](https://leetcode.com/problems/binary-tree-level-order-traversal-ii/)|[Solution](../master/src/main/java/com/stevesun/solutions/BinaryTreeLevelOrderTraversalII.java)| O(nlogn)|O(h) | Easy| BFS
+|106|[Construct Binary Tree from Inorder and Postorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/)|[Solution](../master/src/main/java/com/stevesun/solutions/_106.java)| O(n)|O(n) | Medium| Recursion, Tree
 |105|[Construct Binary Tree from Preorder and Inorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/)|[Solution](../master/src/main/java/com/stevesun/solutions/_105.java)| O(n)|O(n) | Medium| Recursion, Tree 
 |104|[Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/)|[Solution](../master/src/main/java/com/stevesun/solutions/MaximumDepthOfBinaryTree.java)| O(n)|O(h) | Easy| DFS
 |103|[Binary Tree Zigzag Level Order Traversal](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/)|[Solution](../master/src/main/java/com/stevesun/solutions/BinaryTreeZigzagLevelOrderTraversal.java)| O(n)|O(h) | Medium| BFS,DFS
diff --git a/src/main/java/com/stevesun/solutions/_106.java b/src/main/java/com/stevesun/solutions/_106.java
@@ -0,0 +1,45 @@
+package com.stevesun.solutions;
+
+import com.stevesun.common.classes.TreeNode;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 106. Construct Binary Tree from Inorder and Postorder Traversal
+ *
+ * Given inorder and postorder traversal of a tree, construct the binary tree.
+
+ Note:
+ You may assume that duplicates do not exist in the tree.
+
+ */
+public class _106 {
+
+    //credit: https://discuss.leetcode.com/topic/3296/my-recursive-java-code-with-o-n-time-and-o-n-space
+    /**The idea is to take the last element in postorder as the root; find the position of the root in the inorder array; then locate the range for left sub-tree and right sub-tree and do recursion,
+     * use a hashmap to record the index of root in the inorder array.*/
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        if (inorder == null || postorder == null || inorder.length != postorder.length) {
+            return null;
+        }
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            map.put(inorder[i], i);
+        }
+        return buildTreeRecursively(0, inorder.length-1, postorder, 0, postorder.length-1,map);
+    }
+
+    private TreeNode buildTreeRecursively(int inorderStart, int inorderEnd, int[] postorder, int postorderStart, int postorderEnd, Map<Integer, Integer> map){
+        if (postorderStart > postorderEnd || inorderStart > inorderEnd) return null;
+        TreeNode root = new TreeNode(postorder[postorderEnd]);
+        int inRoot = map.get(postorder[postorderEnd]);
+        TreeNode leftchild = buildTreeRecursively(inorderStart, inRoot-1, postorder, postorderStart, postorderStart+inRoot-inorderStart-1, map);
+        TreeNode rightchild = buildTreeRecursively(inRoot+1, inorderEnd, postorder, postorderStart+inRoot-inorderStart, postorderEnd-1, map);
+        root.left = leftchild;
+        root.right = rightchild;
+        return root;
+    }
+
+
+}
diff --git a/src/test/java/com/stevesun/_106Test.java b/src/test/java/com/stevesun/_106Test.java
@@ -0,0 +1,66 @@
+package com.stevesun;
+
+import com.stevesun.common.classes.TreeNode;
+import com.stevesun.solutions._106;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.Assert.assertEquals;
+
+/**
+ * Created by stevesun on 5/12/17.
+ */
+public class _106Test {
+    private static _106 test;
+    private static TreeNode expected;
+    private static TreeNode actual;
+    private static int[] inorder;
+    private static int[] postorder;
+
+    @BeforeClass
+    public static void setup(){
+        test = new _106();
+    }
+
+    @Test
+    public void test1(){
+        /**it should be a tree like this:
+         *    3
+         *   /
+         *  1
+         *   \
+         *   2
+         */
+        inorder = new int[]{2,1,3};
+        postorder = new int[]{1,2,3};
+        actual = test.buildTree(postorder, inorder);
+        expected = new TreeNode(3);
+        expected.left = new TreeNode(1);
+        expected.left.right = new TreeNode(2);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2(){
+        /**it should be a tree like this:
+         *    3
+         *   /
+         *  1
+         *   \
+         *   5
+         *  /
+         * 2
+         *  \
+         *  4
+         */
+        inorder = new int[]{4,2,5,1,3};
+        postorder = new int[]{1,2,4,5,3};
+        actual = test.buildTree(postorder, inorder);
+        expected = new TreeNode(3);
+        expected.left = new TreeNode(1);
+        expected.left.right = new TreeNode(5);
+        expected.left.right.left = new TreeNode(2);
+        expected.left.right.left.right = new TreeNode(4);
+        assertEquals(expected, actual);
+    }
+}
