feat(solution): add solution 0105 [Java]

Construct Binary Tree from Preorder and Inorder Traversal

Author: yanglbme

README.md

@@ -87,6 +87,7 @@ Complete [solutions](https://github.com/doocs/leetcode/tree/master/solution) to
 | 0094 | [Binary Tree Inorder Traversal](https://github.com/doocs/leetcode/tree/master/solution/0094.Binary%20Tree%20Inorder%20Traversal) | `Hash Table`, `Stack`, `Tree` |
 | 0096 | [Unique Binary Search Trees](https://github.com/doocs/leetcode/tree/master/solution/0096.Unique%20Binary%20Search%20Trees) | `Tree`, `Dynamic Programming` |
 | 0102 | [Binary Tree Level Order Traversal](https://github.com/doocs/leetcode/tree/master/solution/0102.Binary%20Tree%20Level%20Order%20Traversal) | `Tree`, `Breadth-first Search` |
+| 0105 | [Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/doocs/leetcode/tree/master/solution/0105.Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal) | `Array`, `Tree`, `Depth-first Search` |
 | 0127 | [Word Ladder](https://github.com/doocs/leetcode/tree/master/solution/0127.Word%20Ladder) | `Breadth-first Search` |
 | 0130 | [Surrounded Regions](https://github.com/doocs/leetcode/tree/master/solution/0130.Surrounded%20Regions) | `Depth-first Search`, `Breadth-first Search`, `Union Find` |
 | 0137 | [Single Number II](https://github.com/doocs/leetcode/tree/master/solution/0137.Single%20Number%20II) | `Bit Manipulation` |

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

@@ -3,7 +3,8 @@
 ### 问题描述
 根据一棵树的前序遍历与中序遍历构造二叉树。
 
-注意:
+**注意:**
+
 你可以假设树中没有重复的元素。
 
 例如，给出
@@ -20,46 +21,49 @@
     /  \
    15   7
 ```
----------------
 
-### 思路
+### 解法
 
-利用树的前序遍历和中序遍历特性+递归实现
+利用树的前序遍历和中序遍历特性 + 递归实现。
 
-对树进行前序遍历，每一个元素，在树的中序遍历中找到概元素；在中序遍历中，该元素的左边是它的左子树的全部元素，右边是它的右子树的全部元素，以此为递归条件，确定左右子树的范围
+对树进行前序遍历，每一个元素，在树的中序遍历中找到该元素；在中序遍历中，该元素的左边是它的左子树的全部元素，右边是它的右子树的全部元素，以此为递归条件，确定左右子树的范围。
 
-```CPP
+```java
 /**
  * Definition for a binary tree node.
- * struct TreeNode {
+ * class TreeNode {
  *     int val;
- *     TreeNode *left;
- *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
- * };
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
  */
 class Solution {
-public:
-    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
-        int pRight = preorder.size()-1;
-        int iRight = inorder.size()-1;
-        return build(preorder,inorder,0,pRight,0,iRight);
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        if (preorder == null || inorder == null || preorder.length != inorder.length) {
+            return null;
+        }
+        int n = preorder.length;
+        return n > 0 ? buildTree(preorder, 0, n - 1, inorder, 0, n - 1) : null;
     }
 
-    
-    TreeNode* build(vector<int>& preorder,vector<int>& inorder,int pLeft,int pRight,int iLeft,int iRight){
-        if(pLeft > pRight)return NULL;
-        
-        TreeNode *node = new TreeNode(preorder[pLeft]);
-        int idx = iLeft;
+    private TreeNode buildTree(int[] preorder, int s1, int e1, int[] inorder,  int s2, int e2) {
+        TreeNode node = new TreeNode(preorder[s1]);                           
+        if (s1 == e1 && s2 == e2) {
+            return node;
+        }
+
+        int p = s2;
+        while (inorder[p] != preorder[s1]) {
+            ++p;
+            if (p > e2) {
+                throw new IllegalArgumentException("Invalid input!");
+            }
+        }
 
-        while(inorder[idx] != preorder[pLeft])idx++;
-        node->left = build(preorder,inorder,pLeft+1,pLeft+idx-iLeft,iLeft,idx-1);
-        node->right = build(preorder,inorder,pLeft+idx-iLeft+1,pRight,idx+1,iRight);  
+        node.left = p > s2 ? buildTree(preorder, s1 + 1, s1 - s2 + p, inorder, s2, p - 1) : null;
+        node.right = p < e2 ? buildTree(preorder, s1 - s2 + p + 1, e1, inorder, p + 1, e2) : null;
         return node;
     }
-};
-
-```
-
-
+}
+```

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

@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        if (preorder == null || inorder == null || preorder.length != inorder.length) {
+            return null;
+        }
+        int n = preorder.length;
+        return n > 0 ? buildTree(preorder, 0, n - 1, inorder, 0, n - 1) : null;
+    }
+    
+    private TreeNode buildTree(int[] preorder, int s1, int e1, int[] inorder,  int s2, int e2) {
+        TreeNode node = new TreeNode(preorder[s1]);                           
+        if (s1 == e1 && s2 == e2) {
+            return node;
+        }
+
+        int p = s2;
+        while (inorder[p] != preorder[s1]) {
+            ++p;
+            if (p > e2) {
+                throw new IllegalArgumentException("Invalid input!");
+            }
+        }
+        
+        node.left = p > s2 ? buildTree(preorder, s1 + 1, s1 - s2 + p, inorder, s2, p - 1) : null;
+        node.right = p < e2 ? buildTree(preorder, s1 - s2 + p + 1, e1, inorder, p + 1, e2) : null;
+        return node;
+    }
+}