什么是计数排序

时间  2020-06-29 标签 什么 计数 排序

有这样一道排序题：数组中有20个随机数，取值范围为0待10，要求用最快的速度将这20个整数从小到大进行排序。html

第一时间你可能会使用快速排序，由于快速排序的时间复杂度只有O(nlogn)。可是这种方法仍是不够快，有没有比O(nlogn)更快的排序方法呢？你可能会有疑问：O(nlogn)已是最快的排序算法了，怎么可能还有更快的排序方法？java

让咱们来回顾一下经典的排序算法，不管是归并排序，冒泡排序仍是快速排序等等，都是基于元素之间的比较来进行排序的。可是有一种特殊的排序算法叫作计数排序，这种排序算法不是基于元素比较，而是利用数组下标来肯定元素的正确位置。web

在刚才的题目里，随即整数的取值范围是从0到10，那么这些整数的值确定是在0到10这11个数里面。因而咱们能够创建一个长度为11的数组，数组下标从0到10，元素初始值全为0，以下所示：算法

在这里插入图片描述
先假设20个随机整数的值是：9, 3, 5, 4, 9, 1, 2, 7, 8，1，3, 6, 5, 3, 4, 0, 10, 9, 7, 9数组

让咱们先遍历这个无序的随机数组，每个整数按照其值对号入座，对应数组下标的元素进行加1操做。ide

好比第一个整数是9，那么数组下标为9的元素加1：
在这里插入图片描述
第二个整数是3，那么数组下标为3的元素加1：
在这里插入图片描述
继续遍历数列并修改数组…svg

最终，数列遍历完毕时，数组的状态以下：
在这里插入图片描述
数组中的每个值，表明了数列中对应整数的出现次数。性能

有了这个统计结果，排序就很简单了，直接遍历数组，输出数组元素的下标值，元素的值是几，就输出几回：动画

0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 6, 7, 7, 8, 9, 9, 9, 9, 10spa

显然，这个输出的数列已是有序的了。

这就是计数排序的基本过程，它适用于必定范围的整数排序。在取值范围不是很大的状况下，它的性能在某些状况甚至快过那些O(nlogn)的排序，例如快速排序、归并排序。

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[] coutArray = new int[max + 1];
    //3.遍历数列，填充统计数组
    for(int i = 0; i < array.length; i++)
        coutArray[array[i]]++;

    //4.遍历统计数组，输出结果
    int index = 0;
    int[] sortedArray = new int[array.length];
    for (int i = 0; i < coutArray.length; i++) {
        for (int j = 0; j < coutArray[i]; j++) {
            sortedArray[index++] = i;
        }
    }

    return sortedArray;
}

这段代码在一开始补充了一个步骤，就是求得数列的最大整数值max，后面建立的数组countArray,长度就是max+1，以此保证数组最后一个下标是max。

从功能角度来看，这段代码能够实现整数的排序。可是这段代码其实并不严谨。

好比这个数列：95, 94, 91, 98, 99, 90, 99, 93, 91, 92。该数列最大值是99，但最小值是90，若是咱们只以数列的最大值来决定统计数组的长度的话，就要建立长度为100的数组，那么就会浪费前面90个空间。

为了解决这个问题，咱们再也不以（输入数列的最大值+1）做为统计数组的长度，而是以（数列最大值和最小值的差+1）做为统计数组的长度。同时，数列的最小值做为一个偏移量，用于统计数组的对号入座。

以刚才的数列为例，统计数组的长度为 99-90+1=10，偏移量等于数列最小值90。

对于第一个整数95，对应的统计数组下标为95-90=5，如图所示：
在这里插入图片描述

public static int[] countSort(int[] arr){
        //1.获得数列的最值
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++){
            if (arr[i] > max){
                max = arr[i];
            }

            if (arr[i] < min){
                min = arr[i];
            }
        }

        //2.根据数列的最值肯定统计数组的长度
        int []countArray = new int[max - min + 1];
        //3.遍历数列，填充统计数组
        for (int i = 0; i < arr.length; i++){
            countArray[arr[i] - min]++;
        }


        //4.遍历统计数组，输出结果
        int index = 0;
        int[] sortArray = new int[arr.length];
        for (int i = 0; i < countArray.length; i++){
            while (countArray[i] > 0){
                sortArray[index++] = i + min;
                countArray[i]--;
            }
        }

        return sortArray;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{95, 94, 91, 98, 99, 90, 99, 93, 91, 92};

        int[] brr = countSort(arr);

        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(brr));
    }

进阶一：

步骤：
第一步：求出原始数组的最大值和最小值
在这里插入图片描述
第二步：建立一个max - min + 1 长度的中间数组count
在这里插入图片描述
第三步：遍历原始数组，而且将其映射到中间数组：以原数组中的元素做为count数组的索引，以原数组中的元素出现次数做为count数组的元素值。
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
第四步：对count数组变形，新元素的值是前面元素累加之和的值，即count[i+1] = count[i+1] + count[i];
在这里插入图片描述
第五步：建立一个和原始数组长度同样的结果数组
在这里插入图片描述
第六步：从头开始遍历原始数组，并经过中间数组填充结果数组：当前元素A[j]减去最小值min，做为索引，在计数数组中找到对应的元素值count[A[j]-min]，再将count[A[j]-min]的值减去1，就是A[j]在结果数组result中的位置，作完上述这些操做，count[A[j]-min]自减1。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public int[] countSort3(int[] A) {
    // 找出数组A中的最大值、最小值
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for (int num : A) {
        max = Math.max(max, num);
        min = Math.min(min, num);
    }
    // 初始化计数数组count
    // 长度为最大值减最小值加1
    int[] count = new int[max-min+1];
    // 对计数数组各元素赋值
    for (int num : A) {
        // A中的元素要减去最小值，再做为新索引
        count[num-min]++;
    }
    // 计数数组变形，新元素的值是前面元素累加之和的值
    for (int i=1; i<count.length; i++) {
        count[i] += count[i-1];
    }
    // 建立结果数组
    int[] result = new int[A.length];
    // 遍历A中的元素，填充到结果数组中去
    for (int j=0; j<A.length; j++) {
        result[count[A[j]-min]-1] = A[j];
        count[A[j]-min]--;
    }
    return result;
}

若是咱们想要原始数组中的相同元素按照原本的顺序的排列，那该怎么处理呢？

依旧以上一个数组{101,109,107,103,108,102,103,110,107,103}为例，其中有两个107，咱们要实现第二个107在排序后依旧排在第一个107的后面，能够在第六步的时候，作下变更就能够实现，用倒序的方式遍历原始数组，即从后往前遍历A数组。

在这里插入图片描述
在这里插入图片描述

public int[] countSort4(int[] A) {
    // 找出数组A中的最大值、最小值
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for (int num : A) {
        max = Math.max(max, num);
        min = Math.min(min, num);
    }
    // 初始化计数数组count
    // 长度为最大值减最小值加1
    int[] count = new int[max-min+1];
    // 对计数数组各元素赋值
    for (int num : A) {
        // A中的元素要减去最小值，再做为新索引
        count[num-min]++;
    }
    // 计数数组变形，新元素的值是前面元素累加之和的值
    for (int i=1; i<count.length; i++) {
        count[i] += count[i-1];
    }
    // 建立结果数组
    int[] result = new int[A.length];
    // 遍历A中的元素，填充到结果数组中去，从后往前遍历
    for (int j=A.length-1; j>=0; j--) {
        result[count[A[j]-min]-1] = A[j];
        count[A[j]-min]--;
    }
    return result;
}

既然从后往前遍历原始数组的元素能够保证其原始排序，那么从前日后可不能够达到相同的效果？

答案时能够的。待研究

虽然计数排序看上去很强大，可是它存在两大局限性：

1.当数列最大最小值差距过大时，并不适用于计数排序

好比给定20个随机整数，范围在0到1亿之间，此时若是使用计数排序的话，就须要建立长度为1亿的数组，不但严重浪费了空间，并且时间复杂度也随之升高。

2.当数列元素不是整数时，并不适用于计数排序

若是数列中的元素都是小数，好比3.1415，或是0.00000001这样子，则没法建立对应的统计数组，这样显然没法进行计数排序。

正是因为这两大局限性，才使得计数排序不像快速排序、归并排序那样被人们普遍适用。

https://www.cnblogs.com/xiaochuan94/p/11198610.html
动画

联系我们 沪ICP备13005482号-10