feat: add solutions to leetcode problem: No.0106

See https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/

Author: yanglbme

README.md

@@ -87,6 +87,7 @@
 1. [二叉树的层次遍历](/solution/0100-0199/0102.Binary%20Tree%20Level%20Order%20Traversal/README.md)
 1. [二叉树的最大深度](/solution/0100-0199/0104.Maximum%20Depth%20of%20Binary%20Tree/README.md)
 1. [从前序与中序遍历序列构造二叉树](/solution/0100-0199/0105.Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/README.md)
+1. [从中序与后序遍历序列构造二叉树](/solution/0100-0199/0106.Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal/README.md)
 1. [二叉树的最近公共祖先](/solution/0200-0299/0235.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree/README.md)
 1. [二叉搜索树的最近公共祖先](/solution/0200-0299/0236.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree/README.md)
 

README_EN.md

@@ -85,6 +85,7 @@ Complete solutions to [LeetCode](https://leetcode-cn.com/problemset/all/), [LCOF
 1. [Binary Tree Level Order Traversal](/solution/0100-0199/0102.Binary%20Tree%20Level%20Order%20Traversal/README_EN.md)
 1. [Maximum Depth of Binary Tree](/solution/0100-0199/0104.Maximum%20Depth%20of%20Binary%20Tree/README_EN.md)
 1. [Construct Binary Tree from Preorder and Inorder Traversal](/solution/0100-0199/0105.Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/README_EN.md)
+1. [Construct Binary Tree from Inorder and Postorder Traversal](/solution/0100-0199/0106.Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal/README_EN.md)
 1. [Lowest Common Ancestor of a Binary Tree](/solution/0200-0299/0236.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree/README_EN.md)
 1. [Lowest Common Ancestor of a Binary Search Tree](/solution/0200-0299/0235.Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree/README_EN.md)
 

solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README.md

@@ -89,9 +89,7 @@ class Solution {
     }
 
     private TreeNode buildTree(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
-        if (p1 > p2 || i1 > i2) {
-            return null;
-        }
+        if (p1 > p2 || i1 > i2) return null;
         int rootVal = preorder[p1];
         int pos = find(inorder, rootVal, i1, i2);
         TreeNode root = new TreeNode(rootVal);
@@ -106,7 +104,7 @@ class Solution {
         for (int i = p; i <= q; ++i) {
             if (order[i] == val) return i;
         }
-        return 0;
+        return -1;
     }
 }
 ```

solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/README_EN.md

@@ -82,9 +82,7 @@ class Solution {
     }
 
     private TreeNode buildTree(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
-        if (p1 > p2 || i1 > i2) {
-            return null;
-        }
+        if (p1 > p2 || i1 > i2) return null;
         int rootVal = preorder[p1];
         int pos = find(inorder, rootVal, i1, i2);
         TreeNode root = new TreeNode(rootVal);
@@ -97,7 +95,7 @@ class Solution {
         for (int i = p; i <= q; ++i) {
             if (order[i] == val) return i;
         }
-        return 0;
+        return -1;
     }
 }
 ```

solution/0100-0199/0105.Construct Binary Tree from Preorder and Inorder Traversal/Solution.java

@@ -13,9 +13,7 @@ public TreeNode buildTree(int[] preorder, int[] inorder) {
     }
 
     private TreeNode buildTree(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
-        if (p1 > p2 || i1 > i2) {
-            return null;
-        }
+        if (p1 > p2 || i1 > i2) return null;
         int rootVal = preorder[p1];
         int pos = find(inorder, rootVal, i1, i2);
         TreeNode root = new TreeNode(rootVal);
@@ -28,6 +26,6 @@ private int find(int[] order, int val, int p, int q) {
         for (int i = p; i <= q; ++i) {
             if (order[i] == val) return i;
         }
-        return 0;
+        return -1;
     }
 }

solution/0100-0199/0106.Construct Binary Tree from Inorder and Postorder Traversal/README.md

@@ -28,22 +28,99 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+思路同 [105](/solution/0100-0199/0105.Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/README.md)。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
+        def build(inorder, postorder, i1, i2, p1, p2):
+            if i1 > i2 or p1 > p2:
+                return None
+            root_val = postorder[p2]
+            pos = -1
+            for i in range(i1, i2 + 1):
+                if inorder[i] == root_val:
+                    pos = i
+                    break
+            root = TreeNode(root_val)
+            root.left = None if pos == i1 else build(inorder, postorder, i1, pos - 1, p1, p1 - i1 + pos - 1)
+            root.right = None if pos == i2 else build(inorder, postorder, pos + 1, i2, p1 - i1 + pos, p2 - 1)
+            return root
+        return build(inorder, postorder, 0, len(inorder) - 1, 0, len(postorder) - 1)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        return build(inorder, postorder, 0, inorder.length - 1, 0, postorder.length - 1);
+    }
+
+    private TreeNode build(int[] inorder, int[] postorder, int i1, int i2, int p1, int p2) {
+        if (i1 > i2 || p1 > p2) return null;
+        int rootVal = postorder[p2];
+        int pos = find(inorder, rootVal, i1, i2);
+        TreeNode root = new TreeNode(rootVal);
+        root.left = pos == i1 ? null : build(inorder, postorder, i1, pos - 1, p1, p1 - i1 + pos - 1);
+        root.right = pos == i2 ? null : build(inorder, postorder, pos + 1, i2, p1 - i1 + pos, p2 - 1);
+        return root;
+    }
+
+    private int find(int[] order, int val, int p, int q) {
+        for (int i = p; i <= q; ++i) {
+            if (order[i] == val) return i;
+        }
+        return -1;
+    }
+}
+```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
+        return buildTree(inorder, 0, inorder.size() - 1, postorder, 0, postorder.size() - 1);
+    }
+    TreeNode *buildTree(vector<int> &inorder, int iLeft, int iRight, vector<int> &postorder, int pLeft, int pRight) {
+        if (iLeft > iRight || pLeft > pRight) return NULL;
+        TreeNode *cur = new TreeNode(postorder[pRight]);
+        int i = 0;
+        for (i = iLeft; i < inorder.size(); ++i) {
+            if (inorder[i] == cur->val)
+                break;
+        }
+        cur->left = buildTree(inorder, iLeft, i - 1, postorder, pLeft, pLeft + i - iLeft - 1);
+        cur->right = buildTree(inorder, i + 1, iRight, postorder, pLeft + i - iLeft, pRight - 1);
+        return cur;
+    }
+};
 ```
 
 ### **...**

solution/0100-0199/0106.Construct Binary Tree from Inorder and Postorder Traversal/README_EN.md

@@ -41,13 +41,88 @@ postorder = [9,15,7,20,3]</pre>
 ### **Python3**
 
 ```python
-
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
+        def build(inorder, postorder, i1, i2, p1, p2):
+            if i1 > i2 or p1 > p2:
+                return None
+            root_val = postorder[p2]
+            pos = -1
+            for i in range(i1, i2 + 1):
+                if inorder[i] == root_val:
+                    pos = i
+                    break
+            root = TreeNode(root_val)
+            root.left = None if pos == i1 else build(inorder, postorder, i1, pos - 1, p1, p1 - i1 + pos - 1)
+            root.right = None if pos == i2 else build(inorder, postorder, pos + 1, i2, p1 - i1 + pos, p2 - 1)
+            return root
+        return build(inorder, postorder, 0, len(inorder) - 1, 0, len(postorder) - 1)
 ```
 
 ### **Java**
 
 ```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        return build(inorder, postorder, 0, inorder.length - 1, 0, postorder.length - 1);
+    }
+
+    private TreeNode build(int[] inorder, int[] postorder, int i1, int i2, int p1, int p2) {
+        if (i1 > i2 || p1 > p2) return null;
+        int rootVal = postorder[p2];
+        int pos = find(inorder, rootVal, i1, i2);
+        TreeNode root = new TreeNode(rootVal);
+        root.left = pos == i1 ? null : build(inorder, postorder, i1, pos - 1, p1, p1 - i1 + pos - 1);
+        root.right = pos == i2 ? null : build(inorder, postorder, pos + 1, i2, p1 - i1 + pos, p2 - 1);
+        return root;
+    }
+
+    private int find(int[] order, int val, int p, int q) {
+        for (int i = p; i <= q; ++i) {
+            if (order[i] == val) return i;
+        }
+        return -1;
+    }
+}
+```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
+        return buildTree(inorder, 0, inorder.size() - 1, postorder, 0, postorder.size() - 1);
+    }
+    TreeNode *buildTree(vector<int> &inorder, int iLeft, int iRight, vector<int> &postorder, int pLeft, int pRight) {
+        if (iLeft > iRight || pLeft > pRight) return NULL;
+        TreeNode *cur = new TreeNode(postorder[pRight]);
+        int i = 0;
+        for (i = iLeft; i < inorder.size(); ++i) {
+            if (inorder[i] == cur->val)
+                break;
+        }
+        cur->left = buildTree(inorder, iLeft, i - 1, postorder, pLeft, pLeft + i - iLeft - 1);
+        cur->right = buildTree(inorder, i + 1, iRight, postorder, pLeft + i - iLeft, pRight - 1);
+        return cur;
+    }
+};
 ```
 
 ### **...**

solution/0100-0199/0106.Construct Binary Tree from Inorder and Postorder Traversal/Solution.java

@@ -9,30 +9,23 @@
  */
 class Solution {
     public TreeNode buildTree(int[] inorder, int[] postorder) {
-        if (inorder == null || postorder == null || inorder.length != postorder.length) {
-            return null;
-        }
-        int n = inorder.length;
-        return n > 0 ? buildTree(inorder, 0, n - 1, postorder, 0, n - 1) : null;
+        return build(inorder, postorder, 0, inorder.length - 1, 0, postorder.length - 1);
     }
-    
-    private TreeNode buildTree(int[] inorder, int s1, int e1, int[] postorder, int s2, int e2) {
-        TreeNode node = new TreeNode(postorder[e2]);
-        if (s2 == e2 && s1 == e1) {
-            return node;
-        }
-        
-        int p = s1;
-        while (inorder[p] != postorder[e2]) {
-            ++p;
-            if (p > e1) {
-                throw new IllegalArgumentException("Invalid input!");
-            }
+
+    private TreeNode build(int[] inorder, int[] postorder, int i1, int i2, int p1, int p2) {
+        if (i1 > i2 || p1 > p2) return null;
+        int rootVal = postorder[p2];
+        int pos = find(inorder, rootVal, i1, i2);
+        TreeNode root = new TreeNode(rootVal);
+        root.left = pos == i1 ? null : build(inorder, postorder, i1, pos - 1, p1, p1 - i1 + pos - 1);
+        root.right = pos == i2 ? null : build(inorder, postorder, pos + 1, i2, p1 - i1 + pos, p2 - 1);
+        return root;
+    }
+
+    private int find(int[] order, int val, int p, int q) {
+        for (int i = p; i <= q; ++i) {
+            if (order[i] == val) return i;
         }
-        
-        node.left = p > s1 ? buildTree(inorder, s1, p - 1, postorder, s2, p - 1 + s2 - s1) : null;
-        node.right = p < e1 ? buildTree(inorder, p + 1, e1, postorder, p + s2 - s1, e2 - 1) : null;
-        return node;
-        
+        return -1;
     }
 }

solution/0100-0199/0106.Construct Binary Tree from Inorder and Postorder Traversal/Solution.py

@@ -0,0 +1,23 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
+        def build(inorder, postorder, i1, i2, p1, p2):
+            if i1 > i2 or p1 > p2:
+                return None
+            root_val = postorder[p2]
+            pos = -1
+            for i in range(i1, i2 + 1):
+                if inorder[i] == root_val:
+                    pos = i
+                    break
+            root = TreeNode(root_val)
+            root.left = None if pos == i1 else build(inorder, postorder, i1, pos - 1, p1, p1 - i1 + pos - 1)
+            root.right = None if pos == i2 else build(inorder, postorder, pos + 1, i2, p1 - i1 + pos, p2 - 1)
+            return root
+        return build(inorder, postorder, 0, len(inorder) - 1, 0, len(postorder) - 1)