in-place remove duplicates

Author: idf

src/RemoveDuplicatesfromSortedArray/Solution.java

@@ -0,0 +1,36 @@
+package RemoveDuplicatesfromSortedArray;
+
+/**
+ * User: Danyang
+ * Date: 1/26/2015
+ * Time: 11:55
+ *
+ * Given a sorted array, remove the duplicates in place such that each element appear only once and return the new
+ * length.
+
+ Do not allocate extra space for another array, you must do this in place with constant memory.
+
+ For example,
+ Given input array A = [1,1,2],
+
+ Your function should return length = 2, and A is now [1,2].
+ */
+public class Solution {
+    /**
+     * Two Pointers
+     * @param A
+     * @return
+     */
+    public int removeDuplicates(int[] A) {
+        if(A.length==0)
+            return 0;
+        int i = 0;
+        int j = 1;
+        for(; i<A.length; i++) {
+            while(j<A.length && A[j]==A[i]) j++;
+            if(j==A.length) break;
+            A[i+1] = A[j];
+        }
+        return i+1;
+    }
+}

src/RemoveDuplicatesfromSortedArrayII/Solution.java

@@ -0,0 +1,67 @@
+package RemoveDuplicatesfromSortedArrayII;
+
+/**
+ * User: Danyang
+ * Date: 1/26/2015
+ * Time: 12:18
+ *
+ * Follow up for "Remove Duplicates":
+ What if duplicates are allowed at most twice?
+
+ For example,
+ Given sorted array A = [1,1,1,2,2,3],
+
+ Your function should return length = 5, and A is now [1,1,2,2,3].
+ */
+public class Solution {
+    public int removeDuplicates_error(int[] A) {
+        if(A.length==0)
+            return 0;
+        int i = 0;
+        int j = 1;
+        int allowed = 1;
+        for(; i<A.length; i++, j++) {
+            while(j<A.length && A[j]==A[i]) {
+                allowed--;
+                j++;
+            }
+            if(allowed==0)
+                A[i+1] = A[j-1];
+
+            if(allowed<1)
+                i++;
+
+            if(j==A.length)
+                break;
+            A[i+1] = A[j];
+            allowed = 1;
+        }
+        return i+1;
+    }
+
+    public int removeDuplicates(int [] A) {
+        if(A.length==0)
+            return 0;
+        int i = 0;
+        int j = 1;
+        boolean repeated = false;
+        while(j<A.length) {  // one loop would be clear
+            if(A[i]==A[j] &&!repeated) { // duplicated but not repeated
+                repeated = true;
+                A[i+1] = A[j];
+                j++;
+                i++;
+            }
+            else if(A[i]==A[j] && repeated) { // duplicated and repeated
+                j++;
+            }
+            else {  // not duplicated
+                repeated = false;
+                A[i+1] = A[j];
+                i++;
+                j++;
+            }
+        }
+        return i+1;
+    }
+}

src/RotateList/Solution.java

@@ -0,0 +1,61 @@
+package RotateList;
+
+import commons.datastructures.ListNode;
+
+/**
+ * User: Danyang
+ * Date: 1/26/2015
+ * Time: 11:40
+ *
+ * Given a list, rotate the list to the right by k places, where k is non-negative.
+
+ For example:
+ Given 1->2->3->4->5->NULL and k = 2,
+ return 4->5->1->2->3->NULL.
+ */
+public class Solution {
+    /**
+     * LinkedList, diagram
+     * Notice:
+     * 1. n = n%l;
+     * @param head
+     * @param n
+     * @return
+     */
+    public ListNode rotateRight(ListNode head, int n) {
+        ListNode dummy = new ListNode(0);
+        dummy.next = head;
+        ListNode pre = dummy;
+
+        int cnt = 0;
+        int l = getLength(head);
+        if(l==0)
+            return head;
+        n = n%l;
+        ListNode pre_br = new ListNode(0);
+        ListNode last = new ListNode(0);
+        while(pre.next!=null) {
+            cnt++;
+            if(cnt==l-n)
+                pre_br = pre.next;
+            pre = pre.next;
+            if(pre.next==null)
+                last = pre;
+        }
+
+        last.next = dummy.next;
+        dummy.next = pre_br.next;
+        pre_br.next = null;
+        return dummy.next;
+    }
+
+    int getLength(ListNode head) {
+        ListNode cur = head;
+        int l = 0;
+        while(cur!=null) {
+            l++;
+            cur = cur.next;
+        }
+        return l;
+    }
+}