75. Sort Colors

Problem Statement: 

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.

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?

Solutions

Solution one: two pass

1. First, we keep three counters to record the number of red, white, and blue. 
2. Then, loop to enumerate all the elements in array and update the counter. 
3. Finally, we set the value of nums according to the value of three counters. 

void sortColors(vector<int>& nums) {
        int red_cnt = 0, white_cnt = 0, blue_cnt = 0;
        
        // count the number of red, white, and blue individually
        for(vector<int>::size_type ix = 0; ix < nums.size(); ix++){
            switch(nums[ix]){
                case 0:
                    red_cnt++;
                    break;
                case 1:
                    white_cnt++;
                    break;
                case 2:
                    blue_cnt++;
                    break;
                default:
                    break;
            }
        }
        // set red to 0
        for(vector<int>::size_type ix = 0; ix < red_cnt; ix++){
            nums[ix] = 0;
        }
        // set white to 1
        for(vector<int>::size_type ix = red_cnt; ix < red_cnt + white_cnt; ix++){
            nums[ix] = 1;
        }
        // set blue to 2
        for(vector<int>::size_type ix = red_cnt + white_cnt; ix < red_cnt + white_cnt + blue_cnt; ix++){
            nums[ix] = 2;
        }
        return;
    }

Solution two: one pass

1. We keep two pointer, one is named low, which points to the start position of the array, another is named high, which points to the last element of the array.
2. Second, we enumerate the array one time:
   • if current element is red(0), swap current element with nums[low], meanwhile low++
   • if current element is blue(2), swap current element with nums[high], meanwhile high--
3. Then we get the sorted array

void sortColors(vector<int>& nums) {
        if(nums.empty()){
            return;
        }
        
        // the type of low and high should be int
        // since high should minus one
        // it could be negative value
        int ix = 0, low = 0, high = nums.size() - 1, temp;
        
        while(ix <= high){
            switch(nums[ix]){
                case 0:
                    temp = nums[low];
                    nums[low] = nums[ix];
                    nums[ix] = temp;
                    low++;
                    // increase the pointer when swap an element with low
                    ix++;
                    break;
                case 2:
                    temp = nums[high];
                    nums[high] = nums[ix];
                    nums[ix] = temp;
                    high--;
                    // do not increase the pointer when swap an element with low
                    // we need check the element just swap from end
                    break;
                default:
                    ix++;
                    break;
            }
        }
        return;
}