[leet code] Sort Colors

Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

Note:
You are not suppose to use the library's sort function for this problem.

click to show follow up.

Follow up:
A rather straight forward solution is a two-pass algorithm using counting sort.
First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array with total number of 0's, then 1's and followed by 2's.

Could you come up with an one-pass algorithm using only constant space?

==================

Analysis:

Before clicking "Follow up", we can use the most basic sorting approach to solve the problem:

// Basic Method
public class Solution {
    public void sortColors(int[] A) {
        if(A.length == 0 || A.length == 1) return;
        
        for (int i=0; i<A.length; i++){
            for (int j=i+1; j<A.length; j++){
                if(A[i]>A[j]){
                    int temp = A[i];
                    A[i] = A[j];
                    A[j] = temp;
                }
            }
        }
        return;
    }
}

According to the "Follow up" instruction, we can implement the  two-pass algorithm as below:

public class Solution {
    public void sortColors(int[] A) {
        int red = 0;
        int white = 0;
        int blue = 0;
        
        if(A.length == 0 || A.length == 1) return;
        
        // count number of 3 color respectively
        for(int i=0; i<A.length; i++){
            if (A[i] == 0) red++;
            else if (A[i] == 1) white++;
            else blue++;
        }
        
        // overwrite the original array with the sorted value
        for (int i=0; i<red; i++)
            A[i] = 0;
        for (int i=red; i<red+white; i++)
            A[i] = 1;
        for (int i=red+white; i<A.length; i++)
            A[i] = 2; 
        return;
    }
}

For the one-pass algorithm, the basic idea of which is to put the red to the front of the array; put the blue to the back of the array.  Accordingly, the white ones will be in the middle of the array.  In order to implement this idea, we need 2 pointers for red and blue respectively.  

During traversing the array (by using pointer i), if we got a red element, we would have 3 cases:

1. Red pointer = i  <- red pointer++, i++

2. Red pointer < i <- switch value, red pointer ++, i remain unchanged

3. Red pointer > i <- do nothing, i++

Similarly, we will have the handling for blue case.  And finally, in the case of white, everything remain un-changed except i++.

public class Solution {
    public void sortColors(int[] A) {
        if(A.length == 0 || A.length == 1) return;
        
        int pointerRed = 0;
        int pointerBlue = A.length-1;
        int i = 0;
        
        while(i<A.length){
            if(A[i]==0){
                if(pointerRed < i){
                    int temp = A[pointerRed];
                    A[pointerRed] = A[i];
                    A[i] = temp;
                    pointerRed++;
                }
                else if(pointerRed == i){
                    pointerRed++; 
                    i++;                    
                }
                else i++;
            }
            
            else if(A[i]==2){
                if(pointerBlue > i){
                    int temp = A[pointerBlue];
                    A[pointerBlue] = A[i];
                    A[i] = temp;
                    pointerBlue--; 
                }
                else if(pointerBlue == i) {
                    pointerBlue--; 
                    i++;                    
                }
                else i++;
            }
            else i++;
        }
    }
}