feat: update leetcode and lcof solutions

Author: yanglbme

lcof/面试题07. 重建二叉树/README.md

@@ -40,21 +40,21 @@
 #         self.right = None
 
 class Solution:
+    indexes = {}
     def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
-        def build(preorder, inorder, p1, p2, i1, i2):
+        def build(preorder, inorder, p1, p2, i1, i2) -> TreeNode:
             if p1 > p2 or i1 > i2:
                 return None
             root_val = preorder[p1]
-            pos = i1
-            while pos <= i2:
-                if inorder[pos] == root_val:
-                    break
-                pos += 1
-            node = TreeNode(root_val)
-            node.left = None if pos == i1 else build(preorder, inorder, p1 + 1, pos - i1 + p1, i1, pos - 1)
-            node.right = None if pos == i2 else build(preorder, inorder, pos - i1 + p1 + 1, p2, pos + 1, i2)
-            return node
-        return build(preorder, inorder, 0, len(preorder) - 1, 0, len(inorder) - 1)
+            pos = self.indexes[root_val]
+            root = TreeNode(root_val)
+            root.left = None if pos == i1 else build(preorder, inorder, p1 + 1, p1 - i1 + pos, i1, pos - 1)
+            root.right = None if pos == i2 else build(preorder, inorder, p1 - i1 + pos + 1, p2, pos + 1, i2)
+            return root
+        n = len(inorder)
+        for i in range(n):
+            self.indexes[inorder[i]] = i
+        return build(preorder, inorder, 0, n - 1, 0, n - 1)
 ```
 
 ### **Java**
@@ -70,18 +70,20 @@ class Solution:
  * }
  */
 class Solution {
+    private Map<Integer, Integer> indexes = new HashMap<>();
+
     public TreeNode buildTree(int[] preorder, int[] inorder) {
-        return build(preorder, inorder, 0, preorder.length - 1, 0, inorder.length - 1);
+        int n = inorder.length;
+        for (int i = 0; i < n; ++i) {
+            indexes.put(inorder[i], i);
+        }
+        return build(preorder, inorder, 0, n - 1, 0, n - 1);
     }
 
     private TreeNode build(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
         if (p1 > p2 || i1 > i2) return null;
         int rootVal = preorder[p1];
-        int pos = i1;
-        while (pos <= i2) {
-            if (inorder[pos] == rootVal) break;
-            ++pos;
-        }
+        int pos = indexes.get(rootVal);
         TreeNode node = new TreeNode(rootVal);
         node.left = pos == i1 ? null : build(preorder, inorder, p1 + 1, pos - i1 + p1, i1, pos - 1);
         node.right = pos == i2 ? null : build(preorder, inorder, pos - i1 + p1 + 1, p2, pos + 1, i2);

lcof/面试题07. 重建二叉树/Solution.java

@@ -8,18 +8,20 @@
  * }
  */
 class Solution {
+    private Map<Integer, Integer> indexes = new HashMap<>();
+
     public TreeNode buildTree(int[] preorder, int[] inorder) {
-        return build(preorder, inorder, 0, preorder.length - 1, 0, inorder.length - 1);
+        int n = inorder.length;
+        for (int i = 0; i < n; ++i) {
+            indexes.put(inorder[i], i);
+        }
+        return build(preorder, inorder, 0, n - 1, 0, n - 1);
     }
 
     private TreeNode build(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
         if (p1 > p2 || i1 > i2) return null;
         int rootVal = preorder[p1];
-        int pos = i1;
-        while (pos <= i2) {
-            if (inorder[pos] == rootVal) break;
-            ++pos;
-        }
+        int pos = indexes.get(rootVal);
         TreeNode node = new TreeNode(rootVal);
         node.left = pos == i1 ? null : build(preorder, inorder, p1 + 1, pos - i1 + p1, i1, pos - 1);
         node.right = pos == i2 ? null : build(preorder, inorder, pos - i1 + p1 + 1, p2, pos + 1, i2);

lcof/面试题07. 重建二叉树/Solution.py

@@ -6,18 +6,18 @@
 #         self.right = None
 
 class Solution:
+    indexes = {}
     def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
-        def build(preorder, inorder, p1, p2, i1, i2):
+        def build(preorder, inorder, p1, p2, i1, i2) -> TreeNode:
             if p1 > p2 or i1 > i2:
                 return None
             root_val = preorder[p1]
-            pos = i1
-            while pos <= i2:
-                if inorder[pos] == root_val:
-                    break
-                pos += 1
-            node = TreeNode(root_val)
-            node.left = None if pos == i1 else build(preorder, inorder, p1 + 1, pos - i1 + p1, i1, pos - 1)
-            node.right = None if pos == i2 else build(preorder, inorder, pos - i1 + p1 + 1, p2, pos + 1, i2)
-            return node
-        return build(preorder, inorder, 0, len(preorder) - 1, 0, len(inorder) - 1)
+            pos = self.indexes[root_val]
+            root = TreeNode(root_val)
+            root.left = None if pos == i1 else build(preorder, inorder, p1 + 1, p1 - i1 + pos, i1, pos - 1)
+            root.right = None if pos == i2 else build(preorder, inorder, p1 - i1 + pos + 1, p2, pos + 1, i2)
+            return root
+        n = len(inorder)
+        for i in range(n):
+            self.indexes[inorder[i]] = i
+        return build(preorder, inorder, 0, n - 1, 0, n - 1)

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

@@ -50,23 +50,23 @@
 #         self.right = None
 
 class Solution:
+    indexes = {}
     def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
         def build(preorder, inorder, p1, p2, i1, i2) -> TreeNode:
             if p1 > p2 or i1 > i2:
                 return None
             root_val = preorder[p1]
-            pos = -1
-            for i in range(i1, i2 + 1):
-                if inorder[i] == root_val:
-                    pos = i
-                    break
+            pos = self.indexes[root_val]
             root = TreeNode(root_val)
             # pos==i1，说明只有右子树，左子树为空
             root.left = None if pos == i1 else build(preorder, inorder, p1 + 1, p1 - i1 + pos, i1, pos - 1)
             # pos==i2，说明只有左子树，右子树为空
             root.right = None if pos == i2 else build(preorder, inorder, p1 - i1 + pos + 1, p2, pos + 1, i2)
             return root
-        return build(preorder, inorder, 0, len(preorder) - 1, 0, len(inorder) - 1)
+        n = len(inorder)
+        for i in range(n):
+            self.indexes[inorder[i]] = i
+        return build(preorder, inorder, 0, n - 1, 0, n - 1)
 ```
 
 ### **Java**
@@ -84,27 +84,26 @@ class Solution:
  * }
  */
 class Solution {
+    private Map<Integer, Integer> indexes = new HashMap<>();
+
     public TreeNode buildTree(int[] preorder, int[] inorder) {
-        return buildTree(preorder, inorder, 0, preorder.length - 1, 0, inorder.length - 1);
+        int n = inorder.length;
+        for (int i = 0; i < n; ++i) {
+            indexes.put(inorder[i], i);
+        }
+        return build(preorder, inorder, 0, n - 1, 0, n - 1);
     }
 
-    private TreeNode buildTree(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
+    private TreeNode build(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
         if (p1 > p2 || i1 > i2) return null;
         int rootVal = preorder[p1];
-        int pos = find(inorder, rootVal, i1, i2);
-        TreeNode root = new TreeNode(rootVal);
+        int pos = indexes.get(rootVal);
+        TreeNode node = new TreeNode(rootVal);
         // pos==i1，说明只有右子树，左子树为空
-        root.left = pos == i1 ? null : buildTree(preorder, inorder, p1 + 1, p1 - i1 + pos, i1, pos - 1);
+        node.left = pos == i1 ? null : build(preorder, inorder, p1 + 1, pos - i1 + p1, i1, pos - 1);
         // pos==i2，说明只有左子树，右子树为空
-        root.right = pos == i2 ? null : buildTree(preorder, inorder, p1 - i1 + pos + 1, p2, pos + 1, i2);
-        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;
+        node.right = pos == i2 ? null : build(preorder, inorder, pos - i1 + p1 + 1, p2, pos + 1, i2);
+        return node;
     }
 }
 ```

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

@@ -47,21 +47,21 @@ inorder = [9,3,15,20,7]</pre>
 #         self.right = None
 
 class Solution:
+    indexes = {}
     def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
         def build(preorder, inorder, p1, p2, i1, i2) -> TreeNode:
             if p1 > p2 or i1 > i2:
                 return None
             root_val = preorder[p1]
-            pos = -1
-            for i in range(i1, i2 + 1):
-                if inorder[i] == root_val:
-                    pos = i
-                    break
+            pos = self.indexes[root_val]
             root = TreeNode(root_val)
             root.left = None if pos == i1 else build(preorder, inorder, p1 + 1, p1 - i1 + pos, i1, pos - 1)
             root.right = None if pos == i2 else build(preorder, inorder, p1 - i1 + pos + 1, p2, pos + 1, i2)
             return root
-        return build(preorder, inorder, 0, len(preorder) - 1, 0, len(inorder) - 1)
+        n = len(inorder)
+        for i in range(n):
+            self.indexes[inorder[i]] = i
+        return build(preorder, inorder, 0, n - 1, 0, n - 1)
 ```
 
 ### **Java**
@@ -77,25 +77,24 @@ class Solution:
  * }
  */
 class Solution {
+    private Map<Integer, Integer> indexes = new HashMap<>();
+
     public TreeNode buildTree(int[] preorder, int[] inorder) {
-        return buildTree(preorder, inorder, 0, preorder.length - 1, 0, inorder.length - 1);
+        int n = inorder.length;
+        for (int i = 0; i < n; ++i) {
+            indexes.put(inorder[i], i);
+        }
+        return build(preorder, inorder, 0, n - 1, 0, n - 1);
     }
 
-    private TreeNode buildTree(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
+    private TreeNode build(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
         if (p1 > p2 || i1 > i2) return null;
         int rootVal = preorder[p1];
-        int pos = find(inorder, rootVal, i1, i2);
-        TreeNode root = new TreeNode(rootVal);
-        root.left = pos == i1 ? null : buildTree(preorder, inorder, p1 + 1, p1 - i1 + pos, i1, pos - 1);
-        root.right = pos == i2 ? null : buildTree(preorder, inorder, p1 - i1 + pos + 1, p2, pos + 1, i2);
-        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;
+        int pos = indexes.get(rootVal);
+        TreeNode node = new TreeNode(rootVal);
+        node.left = pos == i1 ? null : build(preorder, inorder, p1 + 1, pos - i1 + p1, i1, pos - 1);
+        node.right = pos == i2 ? null : build(preorder, inorder, pos - i1 + p1 + 1, p2, pos + 1, i2);
+        return node;
     }
 }
 ```

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

@@ -8,24 +8,23 @@
  * }
  */
 class Solution {
+    private Map<Integer, Integer> indexes = new HashMap<>();
+
     public TreeNode buildTree(int[] preorder, int[] inorder) {
-        return buildTree(preorder, inorder, 0, preorder.length - 1, 0, inorder.length - 1);
+        int n = inorder.length;
+        for (int i = 0; i < n; ++i) {
+            indexes.put(inorder[i], i);
+        }
+        return build(preorder, inorder, 0, n - 1, 0, n - 1);
     }
 
-    private TreeNode buildTree(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
+    private TreeNode build(int[] preorder, int[] inorder, int p1, int p2, int i1, int i2) {
         if (p1 > p2 || i1 > i2) return null;
         int rootVal = preorder[p1];
-        int pos = find(inorder, rootVal, i1, i2);
-        TreeNode root = new TreeNode(rootVal);
-        root.left = pos == i1 ? null : buildTree(preorder, inorder, p1 + 1, p1 - i1 + pos, i1, pos - 1);
-        root.right = pos == i2 ? null : buildTree(preorder, inorder, p1 - i1 + pos + 1, p2, pos + 1, i2);
-        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;
+        int pos = indexes.get(rootVal);
+        TreeNode node = new TreeNode(rootVal);
+        node.left = pos == i1 ? null : build(preorder, inorder, p1 + 1, pos - i1 + p1, i1, pos - 1);
+        node.right = pos == i2 ? null : build(preorder, inorder, pos - i1 + p1 + 1, p2, pos + 1, i2);
+        return node;
     }
 }

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

@@ -6,18 +6,18 @@
 #         self.right = None
 
 class Solution:
+    indexes = {}
     def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
         def build(preorder, inorder, p1, p2, i1, i2) -> TreeNode:
             if p1 > p2 or i1 > i2:
                 return None
             root_val = preorder[p1]
-            pos = -1
-            for i in range(i1, i2 + 1):
-                if inorder[i] == root_val:
-                    pos = i
-                    break
+            pos = self.indexes[root_val]
             root = TreeNode(root_val)
             root.left = None if pos == i1 else build(preorder, inorder, p1 + 1, p1 - i1 + pos, i1, pos - 1)
             root.right = None if pos == i2 else build(preorder, inorder, p1 - i1 + pos + 1, p2, pos + 1, i2)
             return root
-        return build(preorder, inorder, 0, len(preorder) - 1, 0, len(inorder) - 1)
+        n = len(inorder)
+        for i in range(n):
+            self.indexes[inorder[i]] = i
+        return build(preorder, inorder, 0, n - 1, 0, n - 1)

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

@@ -45,21 +45,21 @@
 #         self.right = None
 
 class Solution:
+    indexes = {}
     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
+            pos = self.indexes[root_val]
             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)
+        n = len(inorder)
+        for i in range(n):
+            self.indexes[inorder[i]] = i
+        return build(inorder, postorder, 0, n - 1, 0, n - 1)
 ```
 
 ### **Java**
@@ -77,26 +77,25 @@ class Solution:
  * }
  */
 class Solution {
+    private Map<Integer, Integer> indexes = new HashMap<>();
+
     public TreeNode buildTree(int[] inorder, int[] postorder) {
+        int n = inorder.length;
+        for (int i = 0; i < n; ++i) {
+            indexes.put(inorder[i], i);
+        }
         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);
+        int pos = indexes.get(rootVal);
         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;
-    }
 }
 ```