practice

Author: metanet

src/problems/leetcode/BinaryTreeZigzagLevelOrderTraversal.java

@@ -28,6 +28,35 @@ public String toString() {
         }
     }
 
+    public List<List<Integer>> zigzagLevelOrder2(TreeNode root) {
+        List<List<Integer>> levels = new ArrayList<>();
+        traverse(root, 0, levels);
+
+        for (int i = 1; i < levels.size(); i += 2) {
+            // System.out.println(levels.get(i));
+            Collections.reverse(levels.get(i));
+        }
+
+        return levels;
+    }
+
+    public void traverse(TreeNode node, int level, List<List<Integer>> levels) {
+        if (node == null) {
+            return;
+        }
+
+        List<Integer> vals;
+        if (levels.size() <= level) {
+            vals = new ArrayList<>();
+            levels.add(vals);
+        } else {
+            vals = levels.get(level);
+        }
+        vals.add(node.val);
+        traverse(node.left, level + 1, levels);
+        traverse(node.right, level + 1, levels);
+    }
+
     public static List<List<Integer>> zigzagLevelOrder(TreeNode root) {
         if (root == null) {
             return Collections.emptyList();

src/problems/leetcode/ConstructBinaryTreeFromInorderAndPostorderTraversals.java

@@ -0,0 +1,62 @@
+package problems.leetcode;
+
+import java.util.HashMap;
+import java.util.Map;
+
+// https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/
+public class ConstructBinaryTreeFromInorderAndPostorderTraversals {
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+
+        @Override
+        public String toString() {
+            return "TreeNode{" + "val=" + val + '}';
+        }
+    }
+
+    public static TreeNode buildTree(int[] inorder, int[] postorder) {
+        Map<Integer, Integer> inorderIndices = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            inorderIndices.put(inorder[i], i);
+        }
+        return buildTree(inorder, postorder, inorderIndices, 0, postorder.length - 1, 0, inorder.length - 1);
+    }
+
+    private static TreeNode buildTree(int[] inorder, int[] postorder, Map<Integer, Integer> inorderIndices, int inStart,
+            int inEnd, int postStart, int postEnd) {
+        if (postStart > postEnd) {
+            return null;
+        }
+
+        int val = postorder[postEnd];
+        TreeNode node = new TreeNode(val);
+        int diff = inEnd - inorderIndices.get(val);
+        if (diff > 0) {
+            node.right = buildTree(inorder, postorder, inorderIndices, inEnd - diff + 1,
+                    inEnd, postEnd - diff, postEnd - 1);
+        }
+        node.left = buildTree(inorder, postorder, inorderIndices, inStart,
+                inEnd - diff - 1, postStart, postEnd - diff - 1);
+
+        return node;
+    }
+
+    public static void main(String[] args) {
+        // TreeNode root = new TreeNode(3);
+        // root.left = new TreeNode(9);
+        // root.right = new TreeNode(20);
+        // root.right.left = new TreeNode(15);
+        // root.right.right = new TreeNode(7);
+
+        TreeNode root = buildTree(new int[] {9, 6, 3, 15, 20, 7}, new int[]{6, 9, 15, 7, 20, 3});
+        System.out.println();
+    }
+
+}

src/problems/leetcode/ConstructBinaryTreeFromPreorderAndInorderTraversals.java

@@ -1,5 +1,8 @@
 package problems.leetcode;
 
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
  */
@@ -20,47 +23,46 @@ public String toString() {
         }
     }
 
+    // runtime: O(N)
+    // space: O(N)
     public static TreeNode buildTree(int[] preorder, int[] inorder) {
-        return buildTree(preorder, inorder, 0, 0, preorder.length, inorder.length);
+        Map<Integer, Integer> inorderIndices = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            inorderIndices.put(inorder[i], i);
+        }
+        return buildTree(preorder, inorder, inorderIndices, 0, preorder.length, 0, inorder.length);
     }
 
-    static TreeNode buildTree(int[] preorder, int[] inorder, int startP, int startI, int endP, int endI) {
-        if (startP == endP) {
+    private static TreeNode buildTree(int[] preorder, int[] inorder, Map<Integer, Integer> inorderIndices, int preStart,
+            int preEnd, int inStart, int inEnd) {
+        if (preStart == preEnd) {
             return null;
         }
 
-        TreeNode node = new TreeNode(preorder[startP]);
-
-        int diff = getDiff(preorder[startP], inorder, startI, endI);
+        int val = preorder[preStart];
+        TreeNode node = new TreeNode(val);
+        int diff = inorderIndices.get(val) - inStart;
         if (diff > 0) {
-            node.left = buildTree(preorder, inorder, startP + 1, startI, startP + 1 + diff, startI + diff);
+            node.left = buildTree(preorder, inorder, inorderIndices, 1 + preStart, 1 + preStart + diff, inStart,
+                    inStart + diff);
         }
-        node.right = buildTree(preorder, inorder, startP + diff + 1, startI + diff + 1, endP, endI);
+        node.right = buildTree(preorder, inorder, inorderIndices, 1 + preStart + diff, preEnd, 1 + inStart + diff,
+                inEnd);
 
         return node;
     }
 
-    private static int getDiff(int node, int[] inorder, int startI, int endI) {
-        for (int i = startI; i < endI; i++) {
-            if (node == inorder[i]) {
-                return i - startI;
-            }
-        }
-
-        throw new IllegalArgumentException();
-    }
-
     public static void main(String[] args) {
-        //        TreeNode root = buildTree(new int[]{1, 3}, new int[]{1, 3});
-        //        TreeNode root = buildTree(new int[]{1, 2}, new int[]{2, 1});
-        //        TreeNode root = buildTree(new int[]{1, 2, 3}, new int[]{2, 1, 3});
-        //        TreeNode root = buildTree(new int[]{1, 2, 3}, new int[]{3, 2, 1});
-        //        TreeNode root = buildTree(new int[]{1, 2, 3, 4}, new int[]{3, 2, 4, 1});
-        //        TreeNode root = buildTree(new int[]{1, 2, 3}, new int[]{2, 3, 1});
-        //        TreeNode root = buildTree(new int[]{1, 2, 3}, new int[]{1, 3, 2});
-        //        TreeNode root = buildTree(new int[]{1, 2, 3}, new int[]{1, 2, 3});
-        //        TreeNode root = buildTree(new int[]{1, 2, 3, 4}, new int[]{1, 3, 2, 4});
-        TreeNode root = buildTree(new int[]{3, 9, 20, 15, 7}, new int[]{9, 3, 15, 20, 7});
+        // TreeNode root = buildTree(new int[]{1, 3}, new int[]{1, 3});
+        // TreeNode root = buildTree(new int[]{1, 2}, new int[]{2, 1});
+        // TreeNode root = buildTree(new int[]{1, 2, 3}, new int[]{2, 1, 3});
+        // TreeNode root = buildTree(new int[]{1, 2, 3}, new int[]{3, 2, 1});
+        // TreeNode root = buildTree(new int[]{1, 2, 3, 4}, new int[]{3, 2, 4, 1});
+        // TreeNode root = buildTree(new int[]{1, 2, 3}, new int[]{2, 3, 1});
+        // TreeNode root = buildTree(new int[]{1, 2, 3}, new int[]{1, 3, 2});
+        // TreeNode root = buildTree(new int[]{1, 2, 3}, new int[]{1, 2, 3});
+        // TreeNode root = buildTree(new int[]{1, 2, 3, 4}, new int[]{1, 3, 2, 4});
+        TreeNode root = buildTree(new int[] { 3, 9, 20, 15, 7 }, new int[] { 9, 3, 15, 20, 7 });
         System.out.println();
     }
 }

src/problems/leetcode/ConvertSortedArrayToBinarySearchTree.java

@@ -24,25 +24,26 @@ public String toString() {
 
 
     public static TreeNode sortedArrayToBST(int[] nums) {
-        return nums != null ? sortedArrayToBST(nums, 0, nums.length) : null;
+        if (nums == null || nums.length < 1) {
+            return null;
+        }
+
+        return convert(nums, 0, nums.length - 1);
     }
 
-    // start: inclusive, end: exclusive
-    private static TreeNode sortedArrayToBST(int[] nums, int start, int end) {
-        if (start >= end) {
+    private static TreeNode convert(int[] nums, int l, int r) {
+        if (l > r) {
             return null;
-        } else if (start == end - 1) {
-            return new TreeNode(nums[start]);
         }
 
-        int mid = start + (end - start) / 2;
-        TreeNode node = new TreeNode(nums[mid]);
-        node.left = sortedArrayToBST(nums, start, mid);
-        node.right = sortedArrayToBST(nums, mid + 1, end);
+        int m = (l + r) / 2;
+        TreeNode root = new TreeNode(nums[m]);
+        root.left = convert(nums, l, m - 1);
+        root.right = convert(nums, m + 1, r);
 
-        return node;
+        return root;
     }
-
+    
     public static void main(String[] args) {
         int[] nums = {0, 1, 2};
         TreeNode root = sortedArrayToBST(nums);

src/problems/leetcode/LargestRectangleInHistogram.java

@@ -26,13 +26,13 @@ public static void main(String[] args) {
         x x x x x x x x x
         x x x x x x x x x
          */
-
         int[] heights2 = {3, 3, 4, 3, 4, 5, 3, 2, 2};
 
-        int largest = largestRectangleArea(heights2);
-        System.out.println(largest);
+        System.out.println(largestRectangleArea(heights2));
     }
 
+    // runtime: O(N)
+    // space: O(1)
     public static int largestRectangleArea(int[] heights) {
         // {x, h}
         Deque<int[]> stack = new ArrayDeque<>();
@@ -47,22 +47,20 @@ public static int largestRectangleArea(int[] heights) {
             }
 
             // pop all the heights which are greater than the current height
-            int leftMostX = -1;
+            int leftMost = -1;
             while (stack.size() > 0 && stack.peekLast()[1] > h) {
                 int[] bar = stack.removeLast();
-                int area = bar[1] * (i - bar[0]);
-                maxArea = Math.max(maxArea, area);
-                leftMostX = bar[0];
+                maxArea = Math.max(maxArea, bar[1] * (i - bar[0]));
+                leftMost = bar[0];
             }
 
-            stack.addLast(new int[]{leftMostX, h});
+            stack.addLast(new int[]{leftMost, h});
             stack.addLast(new int[]{i, h});
         }
 
         while (stack.size() > 0) {
             int[] bar = stack.removeLast();
-            int area = bar[1] * (n - bar[0]);
-            maxArea = Math.max(maxArea, area);
+            maxArea = Math.max(maxArea, bar[1] * (n - bar[0]));
         }
 
         return maxArea;

src/problems/leetcode/MaximumDepthOfBinaryTree.java

@@ -0,0 +1,28 @@
+package problems.leetcode;
+
+
+// https://leetcode.com/problems/maximum-depth-of-binary-tree
+public class MaximumDepthOfBinaryTree {
+    
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+
+        @Override
+        public String toString() {
+            return "TreeNode{" +
+                    "val=" + val +
+                    '}';
+        }
+    }
+
+    public int maxDepth(TreeNode root) {
+        return root != null ? 1 + Math.max(maxDepth(root.left), maxDepth(root.right)) : 0;
+    }
+
+}

src/problems/leetcode/MinDepthOfBinaryTree.java

@@ -0,0 +1,35 @@
+package problems.leetcode;
+
+// https://leetcode.com/problems/minimum-depth-of-binary-tree/
+public class MinDepthOfBinaryTree {
+    
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+
+
+    private int minDepth = Integer.MAX_VALUE;
+    
+    public int minDepth(TreeNode root) {
+        traverse(root, 1);
+        return minDepth != Integer.MAX_VALUE ? minDepth : 0;
+    }
+
+    private void traverse(TreeNode root, int h) {
+        if (root == null || h > minDepth) {
+            return;
+        } else if (root.left == null && root.right == null) {
+            minDepth = Math.min(minDepth, h);
+        }
+
+        traverse(root.left, h + 1);
+        traverse(root.right, h + 1);
+    }
+
+}

src/problems/leetcode/PathSum.java

@@ -0,0 +1,30 @@
+package problems.leetcode;
+
+// https://leetcode.com/problems/path-sum
+public class PathSum {
+    
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+
+
+    public boolean hasPathSum(TreeNode root, int targetSum) {
+        if (root == null) {
+            return false;
+        } 
+
+        targetSum -= root.val;
+        if (targetSum == 0 && root.left == null && root.right == null) {
+            return true;
+        }
+        
+        return hasPathSum(root.left, targetSum) || hasPathSum(root.right, targetSum);
+    }
+
+}