905_Sort_Array_By_Parity

Author: qiyuangong

README.md

@@ -170,7 +170,8 @@ Also, there are open source implementations for basic data structs and algorithm
 | 844 | [Backspace String Compare](https://leetcode.com/problems/backspace-string-compare/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/844_Backspace_String_Compare.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/844_Backspace_String_Compare.java) | 1. Stack pop when encounters #, O(n) and O(n)<br>2. Compare string from end to start, O(n) and O(1) |
 | 852 | [Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/852_Peak_Index_in_a_Mountain_Array.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/852_Peak_Index_in_a_Mountain_Array.java) | 1. Scan the array until encountering decline, O(n) and O(1)<br>2. Binary seach with additional check for [i + 1], O(logn) and O(1)|
 | 876 | [Middle of the Linked List](https://leetcode.com/problems/middle-of-the-linked-list/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/876_Middle_of_the_Linked_List.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/876_Middle_of_the_Linked_List.java) | 1. Copy to array, O(n) and O(n)<br>2. Fast and slow point, where fast point is 2 times faster than slow point, O(n) and O(1) |
-| 904 | [Fruit Into Baskets](https://leetcode.com/problems/fruit-into-baskets/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/904_Fruit_Into_Baskets.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/904_Fruit_Into_Baskets.java) | 1. Scan through blocks of tree, O(n) and O(n)<br>2. Mainten a sliding window with start and curr point, O(n) and O(n).  |
+| 904 | [Fruit Into Baskets](https://leetcode.com/problems/fruit-into-baskets/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/904_Fruit_Into_Baskets.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/904_Fruit_Into_Baskets.java) | 1. Scan through blocks of tree, O(n) and O(n)<br>2. Mainten a sliding window with start and curr point, O(n) and O(n). |
+| 905 | [Sort Array By Parity](https://leetcode.com/problems/sort-array-by-parity/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/905_Sort_Array_By_Parity.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/905_Sort_Array_By_Parity.java) | 1. Sort with condition, O(nlogn) and O(1)<br>2. Scan all and split odd and even number into different array, O(n) and O(n)<br>3. In place swap similar to quick sort, O(n) and O(1) |
 | 922 | [Sort Array By Parity II](https://leetcode.com/problems/sort-array-by-parity-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/922_Sort_Array_By_Parity_II.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/922_Sort_Array_By_Parity_II.java) | 1. Place odd and even number in odd and even place, not sort is needed. O(n) and O(1)<br>2. Two points with quick sort swap idea, O(n) and O(1). |
 | 929 | [Unique Email Addresses](https://leetcode.com/problems/unique-email-addresses/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/929_Unique_Email_Addresses.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/929_Unique_Email_Addresses.java) | String handle and hash (or set) |
 | 945 | [Minimum Increment to Make Array Unique](https://leetcode.com/problems/minimum-increment-to-make-array-unique/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/945_Minimum_Increment_to_Make_Array_Unique.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/945_Minimum_Increment_to_Make_Array_Unique.java) | Sort, then list duplicate and missing value in sorted list. O(nlgn) and O(n) |

java/905_Sort_Array_By_Parity.java

@@ -0,0 +1,32 @@
+class Solution {
+    /*public int[] sortArrayByParity(int[] A) {
+        Array.sort(A, (a, b)-> Integer.compare(a%2, b%2));
+        return A;
+    }*/
+
+    /*public int[] sortArrayByParity(int[] A) {
+        int[] ans = new int[A.length];
+        int pos = 0;
+        for (int num: A) 
+            if (num % 2 == 0)
+                ans[pos++] = num;
+        for (int num: A) 
+            if (num % 2 == 1)
+                ans[pos++] = num;
+        return ans;
+    }*/
+
+    public int[] sortArrayByParity(int[] A) {
+        int lo = 0, hi = A.length - 1;
+        while (lo < hi) {
+            if (A[lo] % 2 > A[hi] % 2) {
+                int tmp = A[hi];
+                A[hi] = A[lo];
+                A[lo] = tmp;
+            }
+            if (A[lo] % 2 == 0) lo++;
+            if (A[hi] % 2 == 1) hi--;
+        }
+        return A;
+    }
+}

python/905_Sort_Array_By_Parity.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    # def sortArrayByParity(self, A):
+    #     """
+    #     :type A: List[int]
+    #     :rtype: List[int]
+    #     """
+    #     # Bad idea, O(nlogn)
+    #     A.sort(key=lambda x: x % 2)
+    #     return A
+
+    # def sortArrayByParity(self, A):
+    #     return ([x for x in A if x % 2 == 0] +
+    #             [x for x in A if x % 2 == 1])
+
+    def sortArrayByParity(self, A):
+        # Quit like quick sort or quick selection
+        lo, hi = 0, len(A) - 1
+        while lo < hi:
+            if A[lo] % 2 > A[hi] % 2:
+                A[lo], A[hi] = A[hi], A[lo]
+            if A[lo] % 2 == 0: lo += 1
+            if A[hi] % 2 == 1: hi -= 1
+        return A