Signed-off-by: yuduozhou <[email protected]>

Author: yuduozhou

RecoverBinaryTree.java

@@ -0,0 +1,47 @@
+/**
+ * Definition for binary tree
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    public void recoverTree(TreeNode root) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        ArrayList<TreeNode> inOrder = new ArrayList<TreeNode>();
+        int error1 = 0;
+        int error2 = 0;
+        inOrderTrav(root, inOrder);
+        int prev = 0;
+        for (int i = 1; i < inOrder.size(); i++){
+            // Value is in ascening order.
+            if (inOrder.get(i).val > inOrder.get(prev).val){
+                prev = i;
+            }
+            // Previous node is bigger.
+            else {
+                error1 = prev;
+                break;
+            }
+        }
+        // Find the smallest node afterwards.
+        error2 = prev + 1;
+        for (int i = error2 + 1; i < inOrder.size(); i++){
+            if (inOrder.get(i).val < inOrder.get(error2).val){
+                error2 = i;
+            }
+        }
+        int temp = inOrder.get(error1).val;
+        inOrder.get(error1).val = inOrder.get(error2).val;
+        inOrder.get(error2).val = temp;
+    }
+    public void inOrderTrav(TreeNode root, ArrayList<TreeNode> inOrder){
+        if(root == null) return;
+        inOrderTrav(root.left, inOrder);
+        inOrder.add(root);
+        inOrderTrav(root.right, inOrder);
+    }
+}

RegularExpressionMatching.java

@@ -0,0 +1,65 @@
+// Thanks to heartfire.cc
+
+public class Solution {
+    public boolean isMatch(String s, String p) {
+        //Java note: s.substring(n) will be "" if n == s.length(), but if n > s.length(), index oob error
+        // Start typing your Java solution below
+        // DO NOT write main() function
+ 
+        int i = 0, j = 0;
+        //you don't have to construct a state machine for this problem
+ 
+        if (s.length() == 0) {
+            return checkEmpty(p);
+        }
+ 
+        if (p.length() == 0) {
+            return false;
+        }
+ 
+        char c1 = s.charAt(0);
+        char d1 = p.charAt(0), d2 = '0'; //any init value except '*'for d2 will do
+ 
+        if (p.length()>1){
+            d2 = p.charAt(1);
+        }
+ 
+        if (d2 == '*') {
+            if (compare(c1, d1)) {
+                //fork here: 1. consume the character, and use the same pattern again.
+                //2. keep the character, and skip 'd1*' pattern
+                 
+                //Here is also an opportunity to use DP, but the idea is the same
+                return isMatch(s.substring(1), p) || isMatch(s, p.substring(2)); 
+            }
+            else {
+                return isMatch(s, p.substring(2)); 
+            }
+        }
+        else {
+            if (compare(c1, d1)) {
+                return isMatch(s.substring(1), p.substring(1));
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    
+    public boolean compare(char c1, char d1){
+        return d1 == '.' || c1 == d1;
+    }
+ 
+    public boolean checkEmpty(String p) {
+        if (p.length()%2 != 0) {
+            return false;   
+        }
+ 
+        for (int i = 1; i < p.length(); i+=2) {
+            if (p.charAt(i) != '*') {
+                return false;
+            }
+        }
+        return true;
+    }
+}

RemoveDuplicateFromSortedArray.java

@@ -0,0 +1,12 @@
+public class Solution {
+    public int removeDuplicates(int[] A) {
+        if (A.length == 0) return 0;
+        int i = 0, j = 1;
+        for(; j < A.length; j++){
+            if (A[j] != A[j - 1]) {
+                A[++i] = A[j];
+            }
+        }
+       return ++i;
+    }
+}

RemoveDuplicateFromSortedArrayII.java

@@ -0,0 +1,18 @@
+public class Solution {
+    public int removeDuplicates(int[] A) {
+        if (A.length == 0) return 0;
+        int i = 0, int j = 1;
+        boolean seen
+        for(; j < A.length; j ++){
+            if (A[j] != A[j - 1]) {
+                A[++i] = A[j];
+                seen = false;
+            }
+            else if(!seen){
+                A[++i] = A[j];
+                seen = true;
+            }
+        }
+       return ++i;
+    }
+}

RemoveDuplicateFromSortedList.java

@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode deleteDuplicates(ListNode head) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        if (head == null)  return null;
+        ListNode p1 = head, p2 = p1.next;
+        while(p2 != null){
+            if(p2.val != p1.val){
+                p1 = p2;
+                p2 = p2.next;
+            }
+            else{
+                p2 = p2.next;
+                p1.next = p2;
+            }
+        }
+        return head;
+    }
+}

RemoveDuplicateFromSortedListII.java

@@ -0,0 +1,35 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode deleteDuplicates(ListNode head) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        ListNode sent = new ListNode(0); //Sentinel to guard against the changed head node
+        sent.next = head;
+		ListNode cur = head, prev = sent;
+		while (cur != null) {
+			boolean dup = false;
+			while (cur.next != null && cur.next.val == cur.val) {
+				dup = true;
+				cur = cur.next;
+			}
+			if (dup) {
+				prev.next = cur.next;
+			}
+			else {
+				prev = cur;
+			}
+			cur = cur.next;
+		}
+		return sent.next;
+    }
+}

RemoveElement.java

@@ -0,0 +1,16 @@
+public class Solution {
+    public int removeElement(int[] A, int elem) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        if(A.length == 0) return 0;
+        int slow = 0, fast = 0;
+        while(fast < A.length){
+            if(A[fast] != elem){
+                A[slow] = A[fast];
+                slow ++;
+            }
+            fast ++;
+        }
+        return slow ++;
+    }
+}