lintcode 144 review 19 75

Author: geemaple

README.md

@@ -114,10 +114,12 @@ This is a **continually updated, open source** project.
 | 015.3sum | [cpp](./leetcode/15.3sum.cpp), [python](./leetcode/15.3sum.py) | O(N^2) | O(1) | Medium/S++ | | Awesome
 | 016.3sum-closest | [cpp](./leetcode/16.3sum-closest.cpp), [python](./leetcode/16.3sum-closest.py) | O(N^2) | O(1) | Medium || Cool
 | 018.4sum | [cpp](./leetcode/18.4sum.cpp), [python](./leetcode/18.4sum.py) | O(N^3) | O(1) | Medium || Awesome
+| 019.remove-nth-node-from-end-of-list | [cpp](./leetcode/19.remove-nth-node-from-end-of-list.cpp), [python](./leetcode/19.remove-nth-node-from-end-of-list.py) | O(N) | O(1) | Medium || Perfect
 | 026.remove-duplicates-from-sorted-array | [cpp](./leetcode/26.remove-duplicates-from-sorted-array.cpp), [python](./leetcode/26.remove-duplicates-from-sorted-array.py) | O(N) | O(1) | Easy || Perfect
 | 027.remove-element | [cpp](./leetcode/27.remove-element.cpp), [python](./leetcode/27.remove-element.py) | O(N) | O(1) | Easy
 | 028.implement-strstr | [cpp](./leetcode/28.implement-strstr.cpp), [python](./leetcode/28.implement-strstr.py) | O(M + N) | O(1) | Easy | Pattern Searching | KMP
 | 042.trapping-rain-water | [cpp](./leetcode/42.trapping-rain-water.cpp), [python](./leetcode/42.trapping-rain-water.py) | O(N) | O(1) | Hard | Two Pointers | 
+| 075.sort-colors | [cpp](./leetcode/75.sort-colors.cpp) [python](./leetcode/75.sort-colors.py) | O(N) | O(1) | Medium | counting-sort || Perfect
 | 076.minimum-window-substring | [cpp](./leetcode/76.minimum-window-substring.cpp), [python](./leetcode/76.minimum-window-substring.py) | O(N) | O(N) | Hard
 | 088.merge-sorted-array | [cpp](./leetcode/88.merge-sorted-array.cpp), [python](./leetcode/88.merge-sorted-array.py) | O(N + M) | O(1) | Easy | | Perfect
 | 125.valid-palindrome | [cpp](./leetcode/125.valid-palindrome.cpp), [python](./leetcode/125.valid-palindrome.py) | O(N) | O(1) | Easy || Perfect
@@ -133,13 +135,6 @@ This is a **continually updated, open source** project.
 | 532.k-diff-pairs-in-an-array | [cpp](./leetcode/532.k-diff-pairs-in-an-array.cpp), [python](./leetcode/532.k-diff-pairs-in-an-array.py) | O(N * logN) | O(1) | Easy | Hash |
 | 844.backspace-string-compare | [cpp](./leetcode/844.backspace-string-compare.cpp), [python](./leetcode/844.backspace-string-compare.py) | O(N) | O(1) | Easy | stack
 
-## Two Pointers(legacy)
-| Problem    | Solution    | Time    | Difficulty    | Tag    | Note    |
-| -----------| ------------| --------| --------------| -------| --------|
-| 19.remove-nth-node-from-end-of-list | [cpp](./leetcode/19.remove-nth-node-from-end-of-list.cpp), [python](./leetcode/19.remove-nth-node-from-end-of-list.py) | O(N) | Medium
-| 75.sort-colors | [cpp](./leetcode/75.sort-colors.cpp) [python](./leetcode/75.sort-colors.py) | O(N) | Medium | counting-sort
-
-
 ## Linked List
 
 > There is actually no algorithm in linked list question, but is really tricky to get one right
@@ -402,6 +397,7 @@ This is a **continually updated, open source** project.
 | 092.backpack | [cpp](./lintcode/92.backpack.cpp), [python](./lintcode/92.backpack.py) | O(M*N) | O(M) | Medium | dynamic-programming
 | 125.backpack-ii | [cpp](./lintcode/125.backpack-ii.cpp), [python](./lintcode/125.backpack-ii.py) | O(M*N) | O(M) | Medium/S++ | dynamic-programming
 | 139.subarray-sum-closest | [cpp](./lintcode/139.subarray-sum-closest.cpp), [python](./lintcode/139.subarray-sum-closest.py) | O(NlogN) | O(N) | Medium | Subarray 
+| 144.interleaving-positive-and-negative-numbers | [cpp](./lintcode/144.interleaving-positive-and-negative-numbers.cpp), [python](./lintcode/144.interleaving-positive-and-negative-numbers.py) | O(N) | O(1) | Medium | two-pointers
 | 183.wood-cut | [cpp](./lintcode/183.wood-cut.cpp), [python](./lintcode/183.wood-cut.py) | O(N * LogN) | O(1) | Medium/S-- | binary-search
 | 382.triangle-count | [cpp](./lintcode/382.triangle-count.cpp), [python](./lintcode/382.triangle-count.py) | O(N^2) | O(1) | Medium | two-pointers
 | 390.find-peak-element-ii | [cpp](./lintcode/390.find-peak-element-ii.cpp), [python](./lintcode/390.find-peak-element-ii.py) | O(M + N) | O(1) | Hard/SSS | binary-search

leetcode/19.remove-nth-node-from-end-of-list.py

@@ -11,23 +11,22 @@ def removeNthFromEnd(self, head, n):
         :type n: int
         :rtype: ListNode
         """
-        if head is None:
-            return None
-
-        new_head = ListNode(0)
-        new_head.next = head
-
-
+        newHead = ListNode(0)
+        newHead.next = head
+        
         count = 0
-        current = new_head
-        while(head is not None):
-            count += 1
-            head = head.next
+        fast = newHead
+        slow = newHead
+        
+        while (fast):
+            fast = fast.next
             if count > n:
-                current = current.next
-
-        node = current.next
-        current.next = node.next
-        del node
-
-        return new_head.next
+                slow = slow.next
+            count += 1
+            
+        tmp = slow.next
+        slow.next = slow.next.next
+        del tmp
+        
+        return newHead.next
+            

leetcode/75.sort-colors.cpp

@@ -5,6 +5,7 @@ class Solution {
     void sortColors(vector<int>& nums) {
         int countings[number_of_colors] = {0};
         vector<int> tmp(nums.size(), 0);
+        
         for (auto i = 0; i < nums.size(); ++i)
         {
             countings[nums[i]] += 1;
@@ -30,32 +31,34 @@ class Solution {
 };
 
 class Solution2 {
+private:
+    void swap(vector<int>& nums, int i, int j)
+    {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp; 
+    }
+    
 public:
     void sortColors(vector<int>& nums) {
-        
-        int start = 0;
-        int end = nums.size() - 1;
-        int index = 0;
-        
-        while (index <= end) {
-            
-            if (nums[index] < 1)
+        int k = 0;
+        for (auto i = 0; i < nums.size(); ++i)
+        {
+            if (nums[i] == 0)
             {
-                int tmp = nums[index];
-                nums[index] = nums[start];
-                nums[start] = tmp;
-                start += 1;
+                swap(nums, k, i);
+                k ++;
             }
-            else if(nums[index] > 1)
+        }
+        
+        for (auto i = k; i < nums.size(); ++i)
+        {
+            if (nums[i] == 1)
             {
-                int tmp = nums[index];
-                nums[index] = nums[end];
-                nums[end] = tmp;
-                end -= 1;
-                continue;
+                swap(nums, k, i);
+                k ++;
             }
-            
-            index += 1;
         }
+        
     }
 };

leetcode/75.sort-colors.py

@@ -1,41 +1,43 @@
+# counting sort
+
+number_of_colors = 3
 class Solution(object):
     def sortColors(self, nums):
-        """
-        :type nums: List[int]
-        :rtype: void Do not return anything, modify nums in-place instead.
-        """
+        counting = [0 for i in range(number_of_colors)]
+
+        for n in nums:
+            counting[n] += 1
+
+        for i in range(1, number_of_colors):
+            counting[i] += counting[i - 1]
+
+        tmp = [0 for i in range(len(nums))]
+        for i in range(len(nums)):
+            count = counting[nums[i]]
+            tmp[count - 1] = nums[i]
+            counting[nums[i]] -= 1
+
+        for i in range(len(nums)):
+            nums[i] = tmp[i]
 
-        start = 0
-        end = len(nums) - 1
-        i = 0
 
-        while (i <= end):
-            if (nums[i] == 0):
-                nums[i], nums[start] = nums[start], nums[i]
-                start += 1
-                i += 1
-            elif (nums[i] == 2):
-                nums[i], nums[end] = nums[end], nums[i]
-                end -= 1
-            else:
-                i += 1
-                
 # two loop
 class Solution2(object):
     def sortColors(self, nums):
         """
         :type nums: List[int]
         :rtype: void Do not return anything, modify nums in-place instead.
         """
-        
-        start = 0
-        for i in range(len(nums)):
-            if nums[i] < 1:
-                nums[i], nums[start] = nums[start], nums[i]
-                start += 1
-
-        start = 0
+        k = 0
         for i in range(len(nums)):
+            if nums[i] == 0:
+                nums[i], nums[k] = nums[k], nums[i]
+                k += 1
+                
+        for i in range(k, len(nums)):
+            if nums[i] == 1:
+                nums[i], nums[k] = nums[k], nums[i]
+                k += 1           
             if nums[i] < 2:
                 nums[i], nums[start] = nums[start], nums[i]
                 start += 1        

lintcode/144.interleaving-positive-and-negative-numbers.cpp

@@ -0,0 +1,40 @@
+class Solution {
+public:
+    /*
+     * @param A: An integer array.
+     * @return: nothing
+     */
+    void rerange(vector<int> &A) {
+        // write your code here
+        
+        int k = 0;
+        for (auto i = 0; i < A.size(); ++i)
+        {
+            if (A[i] < 0)
+            {
+                int tmp = A[k];
+                A[k] = A[i];
+                A[i] = tmp;
+                k++;
+            }
+        }
+        
+        int negCount = k;
+        int posCount = A.size() - k;
+        
+        bool isPos = posCount > negCount;
+        
+        for (auto i = 0; i < A.size(); ++i)
+        {
+            if ((isPos && A[i] < 0) || (!isPos && A[i] > 0))
+            {
+                int tmp = A[k];
+                A[k] = A[i];
+                A[i] = tmp;
+                k++;
+            }
+            
+            isPos = !isPos;
+        }
+    }
+};

lintcode/144.interleaving-positive-and-negative-numbers.py

@@ -0,0 +1,25 @@
+class Solution:
+    """
+    @param: A: An integer array.
+    @return: nothing
+    """
+    def rerange(self, A):
+        # write your code here
+        
+        k = 0
+        for i in range(len(A)):
+            if A[i] < 0:
+                A[i], A[k] = A[k], A[i]
+                k += 1
+                
+        neg_count = k
+        pos_count = len(A) - k
+        
+        isPos = pos_count > neg_count
+        
+        for i in range(len(A)):
+            if (isPos and A[i] < 0) or (not isPos and A[i] > 0):
+                A[i], A[k] = A[k], A[i]
+                k += 1
+            
+            isPos = not isPos