Lintcode: Sort Colors II 解題報告

Sort Colors II

原題鏈接： http://lintcode.com/zh-cn/problem/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.

注意

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

樣例

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

挑戰

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?

SOLUTION 1:

使用快排，時間復雜度是O(nlogn),空間復雜度是O(Log(N))

/**
     * @param colors: A list of integer
     * @param k: An integer
     * @return: nothing
     */
    /*
    Solution 1: Using the quick sort.
    */ 
    public void sortKColors1(int[] colors, int k) {
        // write your code here
        if (colors == null) {
            return;
        }
        
        quickSort(colors, 0, colors.length - 1);
    }
    
    public void quickSort(int[] colors, int left, int right) {
        if (left >= right) {
            return;
        }
        
        int pivot = colors[right];
        
        int pos = partition(colors, left, right, pivot);
        
        quickSort(colors, left, pos - 1);
        quickSort(colors, pos + 1, right);
    }
    
    public int partition(int[] colors, int left, int right, int pivot) {
        int leftPoint = left - 1;
        int rightPoint = right;
        
        while (true) {
            while (colors[++leftPoint] < pivot);
            
            while (leftPoint < rightPoint && colors[--rightPoint] > pivot);
            
            if (leftPoint >= rightPoint) {
                break;
            }
            
            swap(colors, leftPoint, rightPoint);
        }
        
        swap(colors, leftPoint, right);
        return leftPoint;
    }
    
    public void swap(int[] colors, int left, int right) {
        int tmp = colors[left];
        colors[left] = colors[right];
        colors[right] = tmp;
    }

 

SOLUTION 2:

inplace，並且O(N)時間復雜度的算法。

我們可以使用類似桶排序的思想，對所有的數進行計數。

1. 從左掃描到右邊，遇到一個數字，先找到對應的bucket.比如

3 2 2 1 4

第一個3對應的bucket是index = 2 (bucket從0開始計算）

2. Bucket 如果有數字，則把這個數字移動到i的position(就是存放起來），然后把bucket記為-1(表示該位置是一個計數器，計1）。

3. Bucket 存的是負數，表示這個bucket已經是計數器，直接減1. 並把color[i] 設置為0 （表示此處已經計算過）

4. Bucket 存的是0，與3一樣處理，將bucket設置為-1， 並把color[i] 設置為0 （表示此處已經計算過）

5. 回到position i，再判斷此處是否為0（只要不是為0，就一直重復2-4的步驟）。

6.完成1-5的步驟后，從尾部到頭部將數組置結果。（從尾至頭是為了避免開頭的計數器被覆蓋）

例子(按以上步驟運算)：

3 2 2 1 4

2 2 -1 1 4

2 -1 -1 1 4

0 -2 -1 1 4

-1 -2 -1 0 4

-1 -2 -1 -1 0

// Solution 2: inplace, O(n) 
    public void sortKColors(int[] colors, int k) {
        // write your code here
        if (colors == null) {
            return;
        }
        
        int len = colors.length;
        for (int i = 0; i < len; i++) {
            // Means need to deal with A[i]
            while (colors[i] > 0) {
                int num = colors[i];
                if (colors[num - 1] > 0) {    
                    // 1. There is a number in the bucket, 
                    // Store the number in the bucket in position i;
                    colors[i] = colors[num - 1];
                    colors[num - 1] = -1;
                } else if (colors[num - 1] <= 0) {
                    // 2. Bucket is using or the bucket is empty.
                    colors[num - 1]--;
                    // delete the A[i];
                    colors[i] = 0;
                }
            }
        }
        
        int index = len - 1;
        for (int i = k - 1; i >= 0; i--) {
            int cnt = -colors[i];
            
            // Empty number.
            if (cnt == 0) {
                continue;
            }
                                
            while (cnt > 0) {
                colors[index--] = i + 1;
                cnt--;
            }
        }

GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/lintcode/array/SortKColors.java