lintcode:Sort Colors II

Given an array of n objects with k different colors (numbered from 1 to k), sort them so that objects of the same color are adjacent, with the colors in the order 1, 2, ... k.

Have you met this question in a real interview?

Notice

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

Example

Given colors=[3, 2, 2, 1, 4], k=4, your code should sort colors in-place to [1, 2, 2, 3, 4].

Challenge

A rather straight forward solution is a two-pass algorithm using counting sort. That will cost O(k) extra memory. Can you do it without using extra memory?

class Solution{
    
private:
    void swap(vector<int> &nums, int i, int j) {
        
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }    
public:
    /**
     * @param colors: A list of integer
     * @param k: An integer
     * @return: nothing
     */    
    void sortColors2(vector<int> &colors, int k) {
        // write your code here
        
        int start = 0;
        int end   = colors.size()-1;
        
        int count = 0;
        while (count < k)
        {
            int minValue = INT_MAX;
            int maxValue = INT_MIN;
            for (int i=start; i<=end; i++)
            {
                minValue = min(minValue, colors[i]);
                maxValue = max(maxValue, colors[i]);
            }
            
            int frontIdx = start;
            int curIdx = start;
            int rearIdx = end;
            
            while (curIdx <= rearIdx)
            {
                if (colors[curIdx] == minValue)
                {
                    swap(colors, curIdx, frontIdx);
                    frontIdx++;
                    curIdx++;
                }
                else if (colors[curIdx] < maxValue)
                {
                    curIdx++;
                }
                else if (colors[curIdx] == maxValue)
                {
                    swap(colors, curIdx, rearIdx);
                    rearIdx--;
                }
            }
            
            count += 2; //每次可以处理当前最大最小的两个数
            start = frontIdx;
            end = rearIdx;
        }
    }
};