LeetCode

Sort Colors

2013.12.22 04:39

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?

Solution1:

　　First solution is the plain counting sort. Count the numbers first and rewrite the array next. This algorithm requires two passes of the array.

　　Time complexity is O(n), space compelxity is O(1).

Accepted code:

// 1WA, 1AC
class Solution {
public:
    void sortColors(int A[], int n) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        if(n <= 0 || A == nullptr){
            return;
        }
        
        int n0, n1, n2;
        int i, j;
        
        // 1WA here, wrong sentence: n0 = n1 = n2;
        n0 = n1 = n2 = 0;
        for(i = 0; i < n; ++i){
            if(A[i] == 0){
                ++n0;
            }else if(A[i] == 1){
                ++n1;
            }else{
                ++n2;
            }
        }
        
        j = 0;
        for(i = 0; i < n0; ++i){
            A[j++] = 0;
        }
        for(i = 0; i < n1; ++i){
            A[j++] = 1;
        }
        for(i = 0; i < n2; ++i){
            A[j++] = 2;
        }
    }
};

Solution2:

　　The one-pass solution for this problem can be done with three iterators, corresponding to 0, 1 and 2. Put 0 on the front, 2 at the back and 1 in the middle.

　　It seems this algorithm is O(n) in time, but it is actually inefficient O(n^2). The process of inserting the "1"s into middle part requires a lot of swap operation. I don't think this is a good choice, because it's no faster than insertion sort.

　　Time complexity is O(n^2), space complexity is O(1).

Accepted code:

// 1TLE, 1WA, 1AC, one-pass but inefficient solution
class Solution {
public:
    void sortColors(int A[], int n) {
        if(n <= 0 || A == nullptr){
            return;
        }
        
        int i0, i1, i2;
        int tmp;
        
        i0 = 0;
        i1 = n - 1;
        i2 = n - 1;
        // 1WA here, it's "<=" instead of "<".
        while(i0 <= i1){
            if(A[i0] == 1){
                tmp = A[i0];
                A[i0] = A[i1];
                A[i1] = tmp;
                --i1;
            }else if(A[i0] == 2){
                tmp = A[i0];
                A[i0] = A[i2];
                A[i2] = tmp;
                --i2;
                if(i2 < i1){
                    //  1TLE here, it's "i1 = i2" instead of "i2 = i1".
                    i1 = i2;
                }
            }else{
                ++i0;
            }
        }
    }
};