Tree and backtrack

Author: rchen102

Java/leetcode 1022.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int sumRootToLeaf(TreeNode root) {
+        return dfs(root, 0);
+    }
+    
+    private int dfs(TreeNode cur, int pathSum) {
+        if (cur == null) return pathSum;
+        pathSum = (pathSum << 1) + cur.val;
+        if (cur.left == null && cur.right == null) return pathSum;
+        int res = 0;
+        if (cur.left != null) res += dfs(cur.left, pathSum);
+        if (cur.right != null) res += dfs(cur.right, pathSum);
+        return res;
+    }
+}

Java/leetcode 112.java

@@ -7,38 +7,46 @@
  *     TreeNode(int x) { val = x; }
  * }
  */
-//Solution1: recursive dfs  T: O(n) S: O(logn)
+//Solution1: recursive post-order  T: O(n) S: O(logn)
 class Solution {
     public boolean hasPathSum(TreeNode root, int sum) {
-        if(root == null) return false;
-        if(root.left == null && root.right == null) return root.val == sum;
-        else return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
+        if (root == null) return false;
+        return dfs(root, 0, sum);
+    }
+    
+    // pathSum: current path sum, not include cur
+    private boolean dfs(TreeNode cur, int pathSum, int sum) {
+        if (cur == null) return false;
+        pathSum += cur.val;
+        if (cur.left == null && cur.right == null) {
+            return pathSum == sum;
+        }
+        return dfs(cur.left, pathSum, sum) || dfs(cur.right, pathSum, sum);
     }
 }
 
 //Solution2: iterative dfs T: O(n) S: O(n/2)
 class Solution {
     public boolean hasPathSum(TreeNode root, int sum) {
         if (root == null) return false;
-        Stack<TreeNode> stackNode = new Stack<>();
-        Stack<Integer> stackSum = new Stack<>();
-        stackNode.push(root);
-        stackSum.push(root.val);
-        while (!stackNode.isEmpty()) {
-            TreeNode cur = stackNode.pop();
-            int tmp = stackSum.pop();
-            // Check whether it is a leaf node
+        Stack<TreeNode> stack = new Stack<>();
+        Stack<Integer> sumStack = new Stack<>();
+        
+        stack.push(root);
+        sumStack.push(root.val);
+        while (!stack.isEmpty()) {
+            TreeNode cur = stack.pop();
+            int curSum = sumStack.pop();
             if (cur.left == null && cur.right == null) {
-                if (tmp == sum) return true;
-            } else {
-                if (cur.right != null) {
-                    stackNode.push(cur.right);
-                    stackSum.push(tmp + cur.right.val);
-                }
-                if (cur.left != null) {
-                    stackNode.push(cur.left);
-                    stackSum.push(tmp + cur.left.val);
-                }
+                if (curSum == sum) return true;
+            }
+            if (cur.right != null) {
+                stack.push(cur.right);
+                sumStack.push(curSum + cur.right.val);
+            }
+            if (cur.left != null) {
+                stack.push(cur.left);
+                sumStack.push(curSum + cur.left.val);
             }
         }
         return false;

Java/leetcode 113.java

@@ -1,20 +1,28 @@
-//Solution1: recursive backtracking dfs T: O(n) S: O(n) worst
+// Solution1: recursive backtrace dfs T: O(n) S: O(n) worst
 class Solution {
     public List<List<Integer>> pathSum(TreeNode root, int sum) {
         List<List<Integer>> res = new ArrayList<>();
-        helper(root, sum, res, new ArrayList<>());
+        dfs(root, sum, new ArrayList<>(), res);
         return res;
     }
 
-    public void helper(TreeNode root, int sum, List<List<Integer>> res, List<Integer> tmp) {
-        if (root == null) return;
-        tmp.add(root.val);
-        if (root.left == null && root.right == null) {  // This is a leaf
-            if (root.val == sum) res.add(new ArrayList<>(tmp));
-        } else { // This is not a leaf
-            helper(root.left, sum - root.val, res, tmp);
-            helper(root.right, sum - root.val, res, tmp);
+    private void dfs(TreeNode cur, int remain, List<Integer> curPath, List<List<Integer>> res) {
+        if (cur == null) return;
+        // update vars with the new step
+        curPath.add(cur.val);
+        remain -= cur.val;
+        
+        // do check for current step
+        if (cur.left == null && cur.right == null) {
+            if (remain == 0) {
+                res.add(new ArrayList<>(curPath));
+            }
         }
-        tmp.remove(tmp.size() - 1);
+        
+        dfs(cur.left, remain, curPath, res);
+        dfs(cur.right, remain, curPath, res);
+        
+        // back one step
+        curPath.remove(curPath.size() - 1);
     }
 }

Java/leetcode 114.java

@@ -7,43 +7,54 @@
  *     TreeNode(int x) { val = x; }
  * }
  */
-//Solution1: recursive T: O(n) S: O(h)
+// Solution1: post-order dfs T: O(n) S: O(h)
 class Solution {
     public void flatten(TreeNode root) {
-        helper(root, null);
+        dfs(root, null);
     }
 
-    private TreeNode helper(TreeNode cur, TreeNode prev) {
-        if(cur == null) return prev;
-        prev = helper(cur.right, prev);
-        prev = helper(cur.left, prev);
-        cur.right = prev;
-        cur.left = null;
-        prev = cur;
-        return prev;
+    /**
+     *  1. flatten root
+     *  2. link the list after root
+     *  3. return the newHead
+     */
+    public TreeNode dfs(TreeNode root, TreeNode linkedList) {
+        if (root == null) return linkedList;
+        linkedList = dfs(root.right, linkedList);
+        linkedList = dfs(root.left, linkedList);
+        root.right = linkedList;
+        root.left = null;
+        linkedList = root;
+        return linkedList;
     }
 }
 
-//Solution2: iterative pre-order search T: O(n) S: O(h)
+// Solution2: iterative pre-order  T: O(n) S: O(h)
 class Solution {
     public void flatten(TreeNode root) {
-        if(root == null) return;
-        Stack<TreeNode> stack = new Stack<TreeNode>();
-        TreeNode start = new TreeNode(0);
-        
-        TreeNode cur;
+        if (root == null) return;
+        Stack<TreeNode> stack = new Stack<>();
         stack.push(root);
-        while(!stack.empty()) {
-            cur = stack.pop();
-            start.right = cur;
-            start = cur;
-            if(cur.right != null)
-                stack.push(cur.right);
-            if(cur.left != null) {
-                stack.push(cur.left);
-                cur.left = null;
+        TreeNode dummy = new TreeNode();
+        TreeNode prev = dummy;
+        while (!stack.isEmpty()) {
+            TreeNode cur = stack.pop();
+            TreeNode left = cur.left;
+            TreeNode right = cur.right;
+            // do some with cur
+            prev.right = cur;
+            cur.left = null;
+            cur.right = null;
+            prev = cur;
+            // push left and child
+            if (right != null) {
+                stack.push(right);
+            }
+            if (left != null) {
+                stack.push(left);
             }
-        }   
+        }
+        prev.right = null;
     }
 }
 

Java/leetcode 129.java

@@ -7,23 +7,26 @@
  *     TreeNode(int x) { val = x; }
  * }
  */
-//Solution1: recursive dfs T: O(n) S: O(h) h = logn
+// Solution1: pre-order recursive T: O(n) S: O(h) h = logn
 class Solution {
     public int sumNumbers(TreeNode root) {
-        if (root == null) return 0;
-        return helper(0, root);
+        return dfs(root, 0);
     }
 
-    public int helper(int tmp, TreeNode root) {
-        tmp = tmp * 10 + root.val;
-        if (root.left == null && root.right == null) {
-            return tmp;
-        } else {
-            int sum = 0;
-            if (root.left != null) sum += helper(tmp, root.left);
-            if (root.right != null) sum += helper(tmp, root.right);
-            return sum;
+    private int dfs(TreeNode cur, int pathSum) {
+        if (cur == null) return pathSum;
+        pathSum = pathSum * 10 + cur.val;
+        if (cur.left == null && cur.right == null) return pathSum;
+        
+        // 如果不是叶子节点，则还不能返回当前的 pathSum，而是将 pathSum 作为参数继续计算
+        int res = 0;
+        if (cur.left != null) {
+            res += dfs(cur.left, pathSum);
         }
+        if (cur.right != null) {
+            res += dfs(cur.right, pathSum);
+        }
+        return res;
     }
 }
 

Java/leetcode 144.java

@@ -23,7 +23,25 @@ public void helper(TreeNode root, List<Integer> res) {
     }
 }
 
-// Solution2: HashMap T: O(n) S: O(n)
+// Solutuon2: iterative T: O(n) S: O(n)
+class Solution {
+    public List<Integer> preorderTraversal(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        if (root == null) return res;
+        stack.push(root);
+        while (!stack.isEmpty()) {
+            TreeNode cur = stack.pop();
+            if (cur == null) continue;
+            res.add(cur.val);
+            stack.push(cur.right);
+            stack.push(cur.left);
+        }
+        return res;
+    }
+}
+
+// Solution3: HashMap T: O(n) S: O(n)
 class Solution {
     public List<Integer> preorderTraversal(TreeNode root) {
         List<Integer> res = new ArrayList<Integer>();
@@ -56,20 +74,4 @@ public List<Integer> preorderTraversal(TreeNode root) {
     }
 }
 
-//Solutuon3: iterative T: O(n) S: O(n)
-class Solution {
-    public List<Integer> preorderTraversal(TreeNode root) {
-        List<Integer> res = new LinkedList<>();
-        if(root == null) return res;
-        Stack<TreeNode> stack = new Stack<>();
-        stack.push(root);
-        while(!stack.isEmpty()) {
-            TreeNode cur = stack.pop();
-            res.add(cur.val);
-            if(cur.right != null) stack.push(cur.right);
-            if(cur.left != null) stack.push(cur.left);
-        }
-        return res;
-    }
-}
 

Java/leetcode 216.java

@@ -1,22 +1,22 @@
 class Solution {
     public List<List<Integer>> combinationSum3(int k, int n) {
-        List<List<Integer>> list = new ArrayList<>();
-        backtrack(list, new ArrayList<>(), k, n, 1);
-        return list;
+        List<List<Integer>> res = new ArrayList<>();
+        backtrack(res, new ArrayList<>(), 1, k, n);
+        return res;
     }
 
-    private void backtrack(List<List<Integer>> list, List<Integer> tempList, int k, int n, int start) {
-        if(tempList.size() == k && n == 0) 
-            list.add(new ArrayList<>(tempList));
-        
-        if(tempList.size() == k) return;
-        
-        else {
-            for(int i = start; i <= 9; i++) {
-                tempList.add(i);
-                backtrack(list, tempList, k, n - i, i + 1);
-                tempList.remove(tempList.size() - 1);
-            }
+    private void backtrack(List<List<Integer>> res, List<Integer> curPath, 
+                           int start, int k, int remain) {
+        if (curPath.size() == k && remain == 0) {
+            res.add(new ArrayList<>(curPath));
+            return;
+        }
+        for (int i = start; i <= 9; i++) {
+            if (curPath.size() >= k) break;
+            if (remain - i < 0) break;
+            curPath.add(i);
+            backtrack(res, curPath, i+1, k, remain - i);
+            curPath.remove(curPath.size() - 1);
         }
     }
 }

Java/leetcode 226.java

@@ -7,30 +7,37 @@
  *     TreeNode(int x) { val = x; }
  * }
  */
-// Solution1: recursion T: O(n) S: O(n) worst
+// Solution1: recursion pre-order T: O(n) S: O(n) 
 class Solution {
     public TreeNode invertTree(TreeNode root) {
-        if(root == null) return null;
-        TreeNode tmp = root.left;
-        root.left = invertTree(root.right);
-        root.right = invertTree(tmp);
+        dfs(root);
         return root;
     }
+    
+    private void dfs(TreeNode cur) {
+        if (cur == null) return;
+        TreeNode tmp = cur.left;
+        cur.left = cur.right;
+        cur.right = tmp;
+        dfs(cur.left);
+        dfs(cur.right);
+    }
 }
 
-// Solution2: iterative T: O(n) S: O(n) (wide = n/2)
+// Solution2: iterative pre-order T: O(n) S: O(n) 
 class Solution {
     public TreeNode invertTree(TreeNode root) {
-        if (root == null) return null;
-        Queue<TreeNode> queue = new LinkedList<>();
-        queue.offer(root);
-        while (!queue.isEmpty()) {
-            TreeNode cur = queue.poll();
+        if (root == null) return root;
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+        while (!stack.isEmpty()) {
+            TreeNode cur = stack.pop();
+            if (cur == null) continue;
             TreeNode tmp = cur.left;
             cur.left = cur.right;
             cur.right = tmp;
-            if (cur.left != null) queue.offer(cur.left);
-            if (cur.right != null) queue.offer(cur.right);
+            stack.push(cur.left);
+            stack.push(cur.right);
         }
         return root;
     }