solve problem Construct Binary Tree From Preorder And Inorder Traversal

Author: P-ppc

README.md

@@ -234,6 +234,7 @@ All solutions will be accepted!
 |131|[Palindrome Partitioning](https://leetcode-cn.com/problems/palindrome-partitioning/description/)|[java/py/js](./algorithms/PalindromePartitioning)|Medium|
 |60|[Permutation Sequence](https://leetcode-cn.com/problems/permutation-sequence/description/)|[java/py/js](./algorithms/PermutationSequence)|Medium|
 |106|[Construct Binary Tree From Inorder And Postorder Traversal](https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/description/)|[java/py/js](./algorithms/ConstructBinaryTreeFromInorderAndPostorderTraversal)|Medium|
+|105|[Construct Binary Tree From Preorder And Inorder Traversal](https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/description/)|[java/py/js](./algorithms/ConstructBinaryTreeFromPreorderAndInorderTraversal)|Medium|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/ConstructBinaryTreeFromPreorderAndInorderTraversal/README.md

@@ -0,0 +1,2 @@
+# Construct Binary Tree From Preorder And Inorder Traversal
+We can solve this problem by recursion

algorithms/ConstructBinaryTreeFromPreorderAndInorderTraversal/Solution.java

@@ -0,0 +1,33 @@
+/**
+ * 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[] preorder, int[] inorder) {
+        return build(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
+    }
+    
+    public TreeNode build(int[] preorder, int preBeg, int preEnd, int[] inorder, int inBeg, int inEnd) {
+        if (inBeg > inEnd) return null;
+        
+        TreeNode root = new TreeNode(preorder[preBeg]);
+        int pos = -1;
+        
+        for (int i = inBeg; i <= inEnd; i++) {
+            if (preorder[preBeg] == inorder[i]) {
+                pos = i;
+                break;
+            }
+        }
+        
+        root.left = build(preorder, preBeg + 1, preBeg + pos - inBeg, inorder, inBeg, pos - 1);
+        root.right = build(preorder, preBeg + pos - inBeg + 1, preEnd, inorder, pos + 1, inEnd);
+            
+        return root;
+    }
+}

algorithms/ConstructBinaryTreeFromPreorderAndInorderTraversal/solution.js

@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number[]} preorder
+ * @param {number[]} inorder
+ * @return {TreeNode}
+ */
+var buildTree = function(preorder, inorder) {
+    return build(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1)
+};
+
+var build = function(preorder, preBeg, preEnd, inorder, inBeg, inEnd) {
+    if (inBeg > inEnd) {
+        return null
+    }
+    
+    let root = new TreeNode(preorder[preBeg]),
+        pos = inorder.indexOf(preorder[preBeg])
+    
+    pos = inBeg <= pos && pos <= inEnd ? pos : -1
+    
+    root.left = build(preorder, preBeg + 1, preBeg + pos - inBeg, inorder, inBeg, pos - 1)
+    root.right = build(preorder, preBeg + pos - inBeg + 1, preEnd, inorder, pos + 1, inEnd)
+    
+    return root
+};

algorithms/ConstructBinaryTreeFromPreorderAndInorderTraversal/solution.py

@@ -0,0 +1,28 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def buildTree(self, preorder, inorder):
+        """
+        :type preorder: List[int]
+        :type inorder: List[int]
+        :rtype: TreeNode
+        """
+        return self.build(preorder, 0, len(preorder) - 1, inorder, 0, len(inorder) - 1)
+    
+    def build(self, preorder, pre_beg, pre_end, inorder, in_beg, in_end):
+        if in_beg > in_end:
+            return None
+        
+        root = TreeNode(preorder[pre_beg])
+        pos = inorder.index(preorder[pre_beg])
+        pos = pos if in_beg <= pos <= in_end else -1
+        
+        root.left = self.build(preorder, pre_beg + 1, pre_beg + pos - in_beg, inorder, in_beg, pos - 1)
+        root.right = self.build(preorder, pre_beg + pos - in_beg + 1, pre_end, inorder, pos + 1, in_end)
+        
+        return root