feat: construct-binary-tree-from-preorder-and-inorder-traversal

Author: minji-go

construct-binary-tree-from-preorder-and-inorder-traversal/minji-go.java

@@ -1,67 +1,31 @@
-/*
-    Problem: https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
-    Description: Given two integer arrays preorder and inorder, construct and return the binary tree.
-    Concept: Array, Hash Table, Divide and Conquer, Tree, Binary Tree
-    Time Complexity: O(N²), Runtime 2ms
-    Space Complexity: O(N), Memory 45.02MB
-*/
-import java.util.HashMap;
-import java.util.Map;
+/**
+ * <a href="https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/">week15-2. construct-binary-tree-from-preorder-and-inorder-traversal</a>
+ * <li>Description: Given two integer arrays preorder and inorder, construct and return the binary tree</li>
+ * <li>Topics: Array, Hash Table, Divide and Conquer, Tree, Binary Tree</li>
+ * <li>Time Complexity: O(N), Runtime 2ms   </li>
+ * <li>Space Complexity: O(N), Memory 44.41MB</li>
+ */
 
 class Solution {
     public TreeNode buildTree(int[] preorder, int[] inorder) {
-        boolean isLeft = true;
-        Map<Integer, TreeNode> parents = new HashMap<>();
-        TreeNode rootNode = null, parentNode = null;
+        Map<Integer, Integer> inorderMap = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            inorderMap.put(inorder[i], i);
+        }
+        return buildTree(preorder, new AtomicInteger(0), inorderMap, 0, inorder.length - 1);
+    }
 
-        for (int pidx=0, iidx=0; pidx<preorder.length; pidx++) {
-            int pval = preorder[pidx];
-            int ival = inorder[iidx];
+    public TreeNode buildTree(int[] preorder, AtomicInteger index, Map<Integer, Integer> inorderMap, int start, int end) {
+        if (start > end) return null;
 
-            if(pidx==0) {
-                rootNode = parentNode = new TreeNode(pval);
-            } else if (isLeft) {
-                parents.put(pval, parentNode);
-                parentNode = parentNode.left = new TreeNode(pval);
-            } else {
-                isLeft = true;
-                parents.put(pval, parentNode);
-                parentNode = parentNode.right = new TreeNode(pval);
-            }
+        int nodeValue = preorder[index.getAndIncrement()];
+        TreeNode node = new TreeNode(nodeValue);
 
-            if(pval==ival) {
-                isLeft = false;
-                TreeNode targetNode = parentNode;
-                while (iidx<inorder.length-1 && parents.get(parentNode.val)!=null) {
-                    if(parentNode.val == inorder[iidx+1]){
-                        iidx++;
-                        targetNode = parentNode;
-                    }
-                    parentNode = parents.get(parentNode.val);
-                }
-                if(iidx<inorder.length-1 && parentNode.val != inorder[iidx+1]){
-                    iidx++;
-                    parentNode = targetNode;
-                } else iidx = iidx+2;
-            }
-        }
+        int nodeIndex = inorderMap.get(nodeValue);
 
-        return rootNode;
+        node.left = buildTree(preorder, index, inorderMap, start, nodeIndex - 1);
+        node.right = buildTree(preorder, index, inorderMap, nodeIndex + 1, end);
+
+        return node;
     }
 }
-
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode() {}
- *     TreeNode(int val) { this.val = val; }
- *     TreeNode(int val, TreeNode left, TreeNode right) {
- *         this.val = val;
- *         this.left = left;
- *         this.right = right;
- *     }
- * }
- */