[leetcode/lintcode 题解] 两个排序数组的中位数排颜色 II

给定一个有n个对象（包括k种不同的颜色，并按照1到k进行编号）的数组，将对象进行分类使相同颜色的对象相邻，并按照1,2，…k的顺序进行排序。

1. 不能使用代码库中的排序函数来解决这个问题
2. k <= n

在线做题地址

样例1

输入: 
[3,2,2,1,4] 
4
输出: 
[1,2,2,3,4]

样例2

输入: 
[2,1,1,2,2] 
2
输出: 
[1,1,2,2,2]

算法一：分治法

运使用rainbowSort，或者说是改动过的quickSort，运用的是分治的思想，不断将当前需要处理的序列分成两个更小的序列处理。

算法思路

• 思路与quickSort大致相同，每次选定一个中间的颜色，这个中间的颜色用给出的k来决定，将小于等于中间的颜色的就放到左边，大于中间颜色的就放到右边，然后分别再递归左右两半。

代码思路

1. 递归函数设置四个参数，序列需要处理区间的左右端点和处理的颜色区间
2. 根据给定的颜色区间决定中间的颜色
3. 将小于等于中间的颜色的就放到左边，大于中间颜色的就放到右边
4. 递归左右两半，直到颜色区间长度等于1

复杂度分析

N为序列长度，K为颜色数

• 空间复杂度：O(1)
• 时间复杂度：O(NlogK)
  • 每次是对K分成左右进行递归，因此有logK层，每层递归遍历到整个序列，长度为N

public class Solution {
    /*
     * @param colors: A list of integer
     * @param k: An integer
     * @return: nothing
     */

    public void sortColors2(int[] colors, int k) {
        if (colors == null || colors.length < 2) {
            return;
        }
        sort(colors, 0, colors.length - 1, 1, k);
    }

    private void sort(int[] colors, int start, int end, int colorFrom, int colorTo) {
        //若处理区间长度为小于等于1或颜色区间长度为1，则不需要再进行处理
        if (start >= end || colorFrom == colorTo) {
            return;
        }
        //设置左右指针以及中间的颜色
        int left = start;
        int right = end;
        int colorMid = colorFrom + (colorTo - colorFrom) / 2;
        
        while (left <= right) {
            //找到左侧大于中间颜色的位置
            while (left <= right && colors[left] <= colorMid) {
                left++;
            }
            //找到右侧小于等于中间颜色的位置
            while (left <= right && colors[right] > colorMid) {
                right--;
            }
            //交换左右指针指向的颜色
            if (left <= right) {
                int temp = colors[left];
                colors[left] = colors[right];
                colors[right] = temp;
            }
        }
        //继续递归处理左右两半序列
        sort(colors, start, right, colorFrom, colorMid);
        sort(colors, left, end, colorMid + 1, colorTo);
    }
}

算法二：计数排序（counting sort）

• 题目要求不使用额外的数组，一种方法是使用彩虹排序(rainbow sort)，但是这样虽然做到了没有使用额外的空间，但是代价是时间复杂度变成了O(N logK)，那么是否有方法做到时间和空间的双赢呢？
• 我们重新考虑计数排序(counting sort)，这里我们需要注意到颜色肯定是1-k，那么k一定小于n，我们是否可以用colors自己本身这个数组作为count数组呢？
• 下面我们介绍一种不占用大量额外空间的计数排序的写法。

算法思路

• 我们用负数代表数字出现的次数，例如colors[i]=-cnt表示数字i出现了cnt次

代码思路

• 我们从左往右遍历colors数组
  • 若colors[i] > 0且colors[colors[i]] < 0，那么colors[colors[i]] -= 1
  • 若colors[i] > 0且colors[colors[i]] > 0，那么先用临时变量temp存下colors[i],将colors[colors[i]]赋值给colors[i]，再将colors[temp] = -1

    注意此时i指针并不需要指向下一个位置，因为交换过来的值还未进行计数

  • 若colors[i] < 0，跳过
• 倒着输出每种颜色
• 另外注意数组下标是从0开始，为了避免n==k导致数组越界的情况，本题中colors[i]对应的计数位为colors[colors[i] - 1]

复杂度分析

NN表示colors数组长度

• 空间复杂度：O(1)
• 时间复杂度：O(N)

public class Solution {
    /**
     * @param colors: A list of integer
     * @param k: An integer
     * @return: nothing
     */

    public void sortColors2(int[] colors, int k) {
        int len = colors.length;
        if(len <= 0) {
            return;
        }

        int index = 0;
        while(index < len) {
            int temp = colors[index] - 1;
            //遇到计数位，跳过
            if(colors[index] <= 0){  
                index++;  
            }
            else {
                //已经作为计数位
                if(colors[temp] <= 0) {
                    colors[temp]--;
                    colors[index] = 0;
                    index++;
                }

                //还未被作为计数位使用
                else {
                    swap(colors[index], colors[temp]);
                    colors[temp] = -1;
                }
            }
        }

        //倒着输出
        int i = len - 1;  
        while(k > 0) {
            for(int j = 0; j>colors[k-1]; j--) {
                colors[i--] = k;
            }
            k--;
        }
    }

    public void swap(int[] colors , int a , int b){
        int temp = colors[a];
        colors[a] = colors[b];
        colors[b] = temp;
        return ;
    }
}

更多题解参考