Sort Array By Parity LT905

Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.

You may return any answer array that satisfies this condition.

Example 1:

Input: [3,1,2,4]
Output: [2,4,3,1]
The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.

Note:

1. 1 <= A.length <= 5000
2. 0 <= A[i] <= 5000

Idea 1. Borrow the partition idea from quicksort, like Dutch flag problem, assume the array is already sorted as required, what to do with new element?

even | odd | ?

Time complexity: O(n)

Space complexity: O(1)

 class Solution {
     private void swap(int[] A, int i, int j) {
         int a = A[i];
         A[i] = A[j];
         A[j] = a;
     }

     public int[] sortArrayByParity(int[] A) {
         int evenEnd = -1;
         for(int i = 0; i < A.length; ++i) {
             if(A[i]%2 == 0) {
                 ++evenEnd;
                 swap(A, evenEnd, i);
             }
         }
         return A;
     }
 }

Idea 1.a Two pointers walking toward each other and swap if not in the right place

 class Solution {
     private void swap(int[] A, int i, int j) {
         int a = A[i];
         A[i] = A[j];
         A[j] = a;
     }

     public int[] sortArrayByParity(int[] A) {
        for(int left = 0, right = A.length-1; left < right; ) {
            while(left < right && A[left]%2 == 0) {
                ++left;
            }

            while(left < right && A[right]%2 == 1) {
                --right;
            }

            if(left < right) {
                swap(A, left, right);
                ++left;
                --right;
            }
        }
         return A;
     }
 }

slightly more cleaner

 class Solution {
     private void swap(int[] A, int i, int j) {
         int a = A[i];
         A[i] = A[j];
         A[j] = a;
     }

     public int[] sortArrayByParity(int[] A) {
        for(int left = 0, right = A.length-1; left < right; ) {
           if(A[left]%2 == 1 && A[right]%2 == 0) {
               swap(A, left, right);
           }

           if(A[left]%2 == 0) {
               ++left;
           }

           if(A[right]%2 == 1) {
               --right;
           }
        }
         return A;
     }
 }

Idea 2. customised comparator to sort

Time complexity: O(nlogn)

Space complexity: O(n)

 class Solution {
     public int[] sortArrayByParity(int[] A) {

         Integer[] B = new Integer[A.length];
         for(int i = 0; i < A.length; ++i) {
             B[i] = A[i];
         }

         Comparator<Integer> cmp = (a, b) -> Integer.compare(a%2, b%2);
         Arrays.sort(B, cmp);

         for(int i = 0; i < A.length; ++i) {
             A[i] = B[i];
         }

         return A;
     }
 }