计 数排序

计数排序

适用于整数，且最大值和最小值的相差不大的范围内的数列。线性复杂度的排序算法。

例，有20个随机整数：9，3，5，4，9，1，2，7，8，1，3，6，5，3，4，0，10，9 ，7，9
以上数列的取值范围为0-10,11个数字

建立一个大小为11的统计数组

每一个整数按照其值对号入座，同时，对应数组下标的元素进行加1操作。

例如第1个整数是9，那么数组下标为9的元素加1。

然后对每一个数字进行上面的操作之后得到以下数组：

每一个下标位置的值代表数列中对应整数出现的次数。

直接遍历数组，输出数组元素的下标值，元素的值是几，就输出几次。
0，1，1，2，3，3，3，4，4，5，5，6，7，7，8，9，9，9，9，10。

    public static int[] countSort(int[] array) {
        //1.得到数列的最大值
        int max = array[0];
        for(int i=1; i<array.length; i++){
            if(array[i] > max){
                max = array[i];
            }
        }
        //2.根据数列最大值确定统计数组的长度
        int[] countArray = new int[max+1];
        //3.遍历数列，填充统计数组
        for(int i=0; i<array.length; i++){
            countArray[array[i]]++;
        }
        //4.遍历统计数组，输出结果
        int index = 0;
        int[] sortedArray = new int[array.length];
        for(int i=0; i<countArray.length; i++){
            for(int j=0; j<countArray[i]; j++){
                sortedArray[index++] = i;
            }
        }
        return sortedArray;
    }
        public static void main(String[] args) {
        int[] array = new int[] {4,4,6,5,3,2,8,1,7,5,6,0,10};
        int[] sortedArray = countSort(array);
        System.out.println(Arrays.toString(sortedArray));
    }

优化

以数列的最大值来决定统计数组的长度，并不靠谱，例如，95，94，91，98，99，90，99，93，91，92，这样需要建立长度为100的数组，那么前面有很大一部分空间是浪费了的，没有人住。
此时，只需要以数列最大值-最小值+1作为统计数组的长度即可，数列的最小值作为一个偏移量，用于计算整数在统计数组中的下标。

以刚才的数列为例，统计出数组的长度为99-90+1=10，偏移量等于数列的最小值90。
对于第1个整数95，对应的统计数组下标是95-90 = 5，如图所示。

到这里，已经解决了因最大值过大而引起的空间浪费问题。

但是，又有一个新问题来了。
如下所示：

一个学生成绩表，要求按成绩从低到高进行排序，如果成绩相同，则遵循原表固有顺序。
填充统计数组以后，只知道有两个成绩并列为95分的同学，却不知道哪一个是小红，哪一个是小绿。

这时，仅需要对统计数组进行变形即可。

从统计数组的第2个元素开始，每一个元素都加上前面所有元素之和。

这样处理之后，让统计数组存储的元素值，等于相应整数的最终排序位置的序号。

第1步，遍历成绩表最后一行的小绿同学的成绩。小绿的成绩是95分，找到countArray下标是5的元素，值是4，代表小绿的成绩排名位置在第4位。
同时，给countArray下标是5的元素值减1，从4变成3，代表下次再遇到95分的成绩时，最终排名是第3。

剩下的其他数一样的操作即可，最后，同样是95分的小红和小绿就能够清楚地排出顺序了，也
正因为此，优化版本的计数排序属于稳定排序。

    public static int[] countSortV2(int[] array) {
        //1.得到数列的最大值和最小值，并算出差值d
        int max = array[0];
        int min = array[0];
        for(int i=1; i<array.length; i++) {
            if(array[i] > max) {
                max = array[i];
            }
            if(array[i] < min) {
                min = array[i];
            }
        }
        int d = max - min;
        //2.创建统计数组并统计对应元素个数
        int[] countArray = new int[d+1];
        for(int i=0; i<array.length; i++) {
            countArray[array[i]-min]++;
        }
        //3.统计数组做变形，后面的元素等于前面的元素之和
        for(int i=1;i<countArray.length;i++) {
            countArray[i] += countArray[i-1];
        }
        //4.倒序遍历原始数列，从统计数组找到正确位置，输出到结果数组
        int[] sortedArray = new int[array.length];
        for(int i=array.length-1;i>=0;i--) {
            sortedArray[countArray[array[i]-min]-1]=array[i];
            countArray[array[i]-min]--;
        }
        return sortedArray;
    }

    public static void main(String[] args) {
        array = new int[] {95,94,91,98,99,90,99,93,91,92};
        sortedArray = countSortV2(array);
        System.out.println(Arrays.toString(sortedArray));
    }

如果有n个数，最大和最小整数的差值是m，时间复杂度和空间复杂度分析：
代码第1、2、4步都涉及遍历原始数列，运算量都是n，第3步遍历统计数列，运算量是m，所以总体运算量是3n+m，去掉系数，时间复杂度是O(n+m)。
只涉及到统计数组的话，空间复杂度是O(m)。

此方法很少被人使用的原因：

1. 当数列最大和最小值差距过大时，并不适合用计数排序。
2. 当数列元素不是整数时，也不适合用计数排序。