一文弄懂计数排序算法!

这是小川的第385次更新,第413篇原创

01 计数排序算法概念

计数排序不是一个比较排序算法,该算法于1954年由 Harold H. Seward提出,通过计数将时间复杂度降到了O(N)

02 基础版算法步骤

第一步:找出原数组中元素值最大的,记为max

第二步:创建一个新数组count,其长度是max加1,其元素默认值都为0。

第三步:遍历原数组中的元素,以原数组中的元素作为count数组的索引,以原数组中的元素出现次数作为count数组的元素值。

第四步:创建结果数组result,起始索引index

第五步:遍历count数组,找出其中元素值大于0的元素,将其对应的索引作为元素值填充到result数组中去,每处理一次,count中的该元素值减1,直到该元素值不大于0,依次处理count中剩下的元素。

第六步:返回结果数组result

03 基础版代码实现

public int[] countSort(int[] A) {
    // 找出数组A中的最大值
    int max = Integer.MIN_VALUE;
    for (int num : A) {
        max = Math.max(max, num);
    }
    // 初始化计数数组count
    int[] count = new int[max+1];
    // 对计数数组各元素赋值
    for (int num : A) {
        count[num]++;
    }
    // 创建结果数组
    int[] result = new int[A.length];
    // 创建结果数组的起始索引
    int index = 0;
    // 遍历计数数组,将计数数组的索引填充到结果数组中
    for (int i=0; i<count.length; i++) {
        while (count[i]>0) {
            result[index++] = i;
            count[i]--;
        }
    }
    // 返回结果数组
    return result;
}

04 优化版

基础版能够解决一般的情况,但是它有一个缺陷,那就是存在空间浪费的问题。

比如一组数据{101,109,108,102,110,107,103},其中最大值为110,按照基础版的思路,我们需要创建一个长度为111的计数数组,但是我们可以发现,它前面的[0,100]的空间完全浪费了,那怎样优化呢?

将数组长度定为max-min+1,即不仅要找出最大值,还要找出最小值,根据两者的差来确定计数数组的长度

public int[] countSort2(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]++;
    }
    // 创建结果数组
    int[] result = new int[A.length];
    // 创建结果数组的起始索引
    int index = 0;
    // 遍历计数数组,将计数数组的索引填充到结果数组中
    for (int i=0; i<count.length; i++) {
        while (count[i]>0) {
            // 再将减去的最小值补上
            result[index++] = i+min;
            count[i]--;
        }
    }
    // 返回结果数组
    return result;
}

05 进阶版步骤

以数组A = {101,109,107,103,108,102,103,110,107,103}为例。

第一步:找出数组中的最大值max、最小值min

第二步:创建一个新数组count,其长度是max-min加1,其元素默认值都为0。

第三步:遍历原数组中的元素,以原数组中的元素作为count数组的索引,以原数组中的元素出现次数作为count数组的元素值。

第四步:对count数组变形新元素的值是前面元素累加之和的值,即count[i+1] = count[i+1] + count[i];

第五步:创建结果数组result,长度和原始数组一样。

第六步:遍历原始数组中的元素,当前元素A[j]减去最小值min,作为索引,在计数数组中找到对应的元素值count[A[j]-min],再将count[A[j]-min]的值减去1,就是A[j]在结果数组result中的位置,做完上述这些操作,count[A[j]-min]自减1。

是不是对第四步和第六步有疑问?为什么要这样操作?

第四步操作,是让计数数组count存储的元素值,等于原始数组中相应整数的最终排序位置,即计算原始数组中的每个数字在结果数组中处于的位置

比如索引值为9的count[9],它的元素值为10,而索引9对应的原始数组A中的元素为9+101=110(要补上最小值min,才能还原),即110在排序后的位置是第10位,即result[9] = 110,排完后count[9]的值需要减1,count[9]变为9。

再比如索引值为6的count[6],他的元素值为7,而索引6对应的原始数组A中的元素为6+101=107,即107在排序后的位置是第7位,即result[6] = 107,排完后count[6]的值需要减1,count[6]变为6。

如果索引值继续为6,在经过上一次的排序后,count[6]的值变成了6,即107在排序后的位置是第6位,即result[5] = 107,排完后count[6]的值需要减1,count[6]变为5。

至于第六步操作,就是为了找到A中的当前元素在结果数组result中排第几位,也就达到了排序的目的。

06 进阶版代码实现





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;
}

07 进阶版的延伸之一

如果我们想要原始数组中的相同元素按照本来的顺序的排列,那该怎么处理呢?

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

从后往前遍历,第一次遇到107(A[8])时,107-101 = 6,count[6] = 7,即第二个107要排在第7位,即result[6] = 107,排序后count[6] = 6

继续往前,第二次遇到107(A[2])时,107-101 = 6,count[6] = 6,即第一个107要排在第6位,即result[5] = 107,排序后count[6] = 5

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;
}

08 进阶版的延伸之二

既然从后往前遍历原始数组的元素可以保证其原始排序,那么从前往后可不可以达到相同的效果?

答案时可以的。

第一步:找出数组中的最大值max、最小值min

第二步:创建一个新数组count,其长度是max-min加1再加1,其元素默认值都为0。

第三步:遍历原数组中的元素,以原数组中的元素作为count数组的索引,以原数组中的元素出现次数作为count数组的元素值。

第四步:对count数组变形,新元素的值是前面元素累加之和的值,即count[i+1] = count[i+1] + count[i];

第五步:创建结果数组result,长度和原始数组一样。

第六步:从前往后遍历原始数组中的元素,当前元素A[j]减去最小值min,作为索引,在计数数组中找到对应的元素值count[A[j]-min],就是A[j]在结果数组result中的位置,做完上述这些操作,count[A[j]-min]自增加1。

依旧以上一个数组{101,109,107,103,108,102,103,110,107,103}为例,其中有两个107,我们要实现第一个107在排序后依旧排在第二个107的前面。

此时计数数组count{0, 1, 2, 5, 5, 5, 5, 7, 8, 9, 10}从前往后遍历原始数组A中的元素。

第一次遇到107(A[2])时,107-101 = 6,count[6] = 5,即第一个107在结果数组中的索引为5,即result[5] = 107,排序后count[6] = 6

第二次遇到107(A[8])时,107-101 = 6,count[6] = 6,即第二个107在结果数组中的索引为6,即result[6] = 107,排序后count[6] = 7

public int[] countSort5(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,再加1
    int[] count = new int[(max-min+1)+1];
    // 对计数数组各元素赋值,count[0]永远为0
    for (int num : A) {
        // A中的元素要减去最小值再加上1,再作为新索引
        count[num-min+1]++;
    }
    // 计数数组变形,新元素的值是前面元素累加之和的值
    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]] = A[j];
        count[A[j]-min]++;
    }
    return result;
}

09 小结

以上就是计数排序算法的全部内容了,虽然它可以将排序算法的时间复杂度降低到O(N),但是有两个前提需要满足:一是需要排序的元素必须是整数,二是排序元素的取值要在一定范围内,并且比较集中。只有这两个条件都满足,才能最大程度发挥计数排序的优势。

posted @ 2019-07-17 08:41  程序员小川  阅读(11151)  评论(2编辑  收藏