Homework 1-3

louis/Combination Sum II.java

@@ -0,0 +1,29 @@
+public class Solution {
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        List<Integer> path = new ArrayList<Integer>();
+        if (candidates == null || candidates.length == 0) {
+             return res;
+        }
+        Arrays.sort(candidates);
+        helper(candidates, path, 0, res, target);
+        return res;
+    }
+    private void helper(int[] candidates, List<Integer> path, int index, List<List<Integer>> res, int target) {
+        if (target == 0) {
+            res.add(new ArrayList<Integer>(path));            
+        }
+        if (index == candidates.length) {
+            return;
+        }
+        int prev = -1;
+        for (int i = index; i < candidates.length; i++) {
+            if (candidates[i] > target) break;
+            if (candidates[i] == prev) continue;
+            path.add(candidates[i]);
+            helper(candidates, path, i+1, res, target-candidates[i]);
+            prev = candidates[i];
+            path.remove(path.size() - 1);
+        }
+    }
+}

louis/Combination Sum III.java

@@ -0,0 +1,19 @@
+public class Solution {
+    public List<List<Integer>> combinationSum3(int k, int n) {
+        List<List<Integer>> res = new ArrayList<List<Integer>> ();
+        List<Integer> path = new ArrayList<Integer> ();
+        helper(res, path, n, 1, k);
+        return res;
+    }
+    private void helper(List<List<Integer>> res, List<Integer> path, int n, int index, int k) {
+        if (n == 0 && path.size() == k) {
+            res.add(new ArrayList<Integer> (path));
+        }
+        for (int j = index; j <= 9; j++) {
+            if (j > n || path.size() > k) break;
+            path.add(j);
+            helper(res, path, n - j, j + 1, k);
+            path.remove(path.size() - 1);
+        }
+    }
+}

louis/Combination Sum.java

@@ -0,0 +1,26 @@
+public class Solution {
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        List<Integer> path = new ArrayList<Integer>();
+        if (candidates == null || candidates.length == 0) {
+             return res;
+        }
+        Arrays.sort(candidates);
+        helper(candidates, path, 0, res, target);
+        return res;
+    }
+    private void helper(int[] candidates, List<Integer> path, int index, List<List<Integer>> res, int target) {
+        if (target == 0) {
+            res.add(new ArrayList<Integer>(path));            
+        }
+        if (index == candidates.length) {
+            return;
+        }
+        for (int i = index; i < candidates.length; i++) {
+            if (candidates[i] > target) break;
+            path.add(candidates[i]);
+            helper(candidates, path, i, res, target-candidates[i]);
+            path.remove(path.size() - 1);
+        }
+    }
+} 

louis/Generate Parentheses.java

@@ -0,0 +1,24 @@
+public class Solution {
+    public List<String> generateParenthesis(int n) {
+        List<String> res = new ArrayList<String> ();
+        String s = "";
+        DFS(res, s, n, n, n*2);
+        return res;
+    }
+    private void DFS(List<String> res, String s, int left, int right, int n) {
+        if (left > right) {
+            return;
+        }
+        if (n == 0) {
+            res.add(s);
+            return;
+        }
+        if (left > 0) {
+            DFS(res, s+"(", left-1, right, n-1);
+        }
+        if (right > 0) {
+            DFS(res, s+")", left, right -1, n-1);
+        }
+
+    }
+}

louis/HW1-Merge Two Sorted Lists.java

@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        ListNode l = new ListNode(0);
+        ListNode p = l;
+        while (l1 != null && l2 != null) {
+            if ( l1.val <= l2.val) {
+                p.next = l1;
+                l1 = l1.next;
+            } else {
+                p.next = l2;
+                l2 = l2.next;
+            }
+            p = p.next;
+        }
+        if ( l1 != null ) {
+            p.next = l1;
+        } 
+        if ( l2 != null ) {
+            p.next = l2;
+        }
+        return l.next;
+    }
+}

louis/HW1-Remove Duplicates from Sorted List II.java

@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public ListNode deleteDuplicates(ListNode head) {
+        if( head == null )
+            return head;
+
+        ListNode fakehead = new ListNode(0);
+        fakehead.next = head;
+        // starts from beginning
+        head = fakehead;
+
+        while (head.next != null && head.next.next != null) {
+            if (head.next.val == head.next.next.val) {
+                int temp = head.next.val;
+                while (head.next != null && head.next.val == temp) {
+                    head.next = head.next.next;
+                }            
+            } else {
+                head = head.next;
+            }
+        }
+        return fakehead.next;
+    }
+}

louis/HW1-Reverse Linked List II.java

@@ -0,0 +1,37 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+ public class Solution {
+    public ListNode reverseBetween(ListNode head, int m, int n) {
+        if ( head == null ) {
+            return head;
+        }
+
+        ListNode fakehead = new ListNode(0);
+        fakehead.next = head;
+        head = fakehead;
+
+        for ( int i = 1; i < m; i++ ) {
+            head = head.next;
+        }
+
+        ListNode beforen = head;
+        ListNode mNode = head.next;
+        ListNode nNode = head.next;
+        ListNode aftern = head.next.next;
+        for ( int i = m; i < n; i++ ) {
+            ListNode t = aftern.next;
+            aftern.next = nNode;
+            nNode = aftern;
+            aftern = t;
+        }
+        beforen.next = nNode;
+        mNode.next = aftern;
+        return fakehead.next;
+    }
+}

louis/HW2-Binary Tree Path

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public List<String> binaryTreePaths(TreeNode root) {
+        List<String> ret = new ArrayList<String>();
+        if (root == null) {
+            return ret;
+        }
+        dfs(root, ret, String.valueOf(root.val));
+        return ret;
+    }
+    private void dfs(TreeNode root, List<String> ret, String path) {
+        if (root.left == null && root.right == null) {
+            ret.add(path);
+            return;
+        }
+        if (root.left != null) {
+            dfs(root.left, ret, path + "->" + root.left.val);
+        }
+        if (root.right != null) {
+            dfs(root.right, ret, path + "->" + root.right.val);
+        }
+    }
+
+}

louis/HW2-Construct Binary Tree from Inorder and Postorder Traversal.java

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    private int findPosition(int[] arr, int start, int end, int key) {
+        int i;
+        for (i = start; i <= end; i++) {
+            if (arr[i] == key) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    private TreeNode helper(int[] inorder, int instart, int inend,
+            int[] postorder, int poststart, int postend) {
+        if (instart > inend)  return null;
+        TreeNode root = new TreeNode(postorder[postend]);
+        int position = findPosition(inorder, instart, inend, root.val);
+        root.left = helper(inorder, instart, position - 1, postorder, poststart, poststart + position - instart - 1);
+        root.right = helper(inorder, position + 1, inend, postorder, poststart + position - instart, postend - 1);
+        return root;
+    }
+
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        return helper(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1);
+    }
+
+}

louis/HW2-Construct Binary Tree from Preorder and Inorder Traversal.java

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    private int findPosition(int[] arr, int start, int end, int key) {
+        for (int i = start;i<= end;i++) {
+            if (arr[i] == key) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        return myBuild(preorder, 0, preorder.length-1, inorder, 0, inorder.length -1 );
+    }
+    private TreeNode myBuild(int[] preorder, int prestart, int preend, int[] inorder, int instart, int inend) {
+        if (instart > inend) {
+            return null;
+        }
+        TreeNode root = new TreeNode(preorder[prestart]);
+        int position = findPosition(inorder, instart, inend, root.val);
+        root.left = myBuild(preorder, prestart+1, prestart + position - instart, inorder, instart, position - 1);
+        root.right = myBuild(preorder, prestart + position - instart +1, preend, inorder, position + 1, inend);
+        return root;
+    }
+}

louis/HW2-Convert Sorted Array to Binary Search Tree.java

@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public TreeNode sortedArrayToBST(int[] nums) {
+        if (nums == null) {
+            return null;
+        };
+        return convert(nums, 0, nums.length-1);
+    }
+    public TreeNode convert(int[] nums, int start, int end) {
+        if (start > end) {
+            return null;
+        }
+        TreeNode mid = new TreeNode(nums[start + (end-start)/2]);
+        mid.left = convert(nums, start, start + (end-start)/2 - 1);
+        mid.right = convert(nums, start + (end-start)/2 +1, end);
+        return mid;
+    }
+}

louis/HW2-Lowest Common Ancestor of a Binary Search Tree.java

@@ -0,0 +1,18 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root.val > p.val && root.val > q.val) {
+            return lowestCommonAncestor(root.left, p, q);
+        } else if (root.val < p.val && root.val < q.val) {
+            return lowestCommonAncestor(root.right, p, q);
+        } else return root;
+    }
+}

louis/HW2-Lowest Common Ancestor of a Binary Tree.java

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == p || root == q || root == null) {
+            return root;
+        } 
+
+        TreeNode left = lowestCommonAncestor(root.left, p, q);
+        TreeNode right = lowestCommonAncestor(root.right, p, q);
+
+        if (left != null && right != null) {
+            return root;
+        }
+        if (left != null) {
+            return left;
+        }
+        if (right != null) {
+            return right;
+        }
+        return null;
+    }
+}

louis/HW2-Maximum Depth of Binary Tree.java

@@ -0,0 +1,17 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        } 
+        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;  
+    }
+}