算法系列：计数排序

最新推荐文章于 2023-06-26 11:02:52 发布

Joey_Zhao

最新推荐文章于 2023-06-26 11:02:52 发布

阅读量479

点赞数

分类专栏：算法

算法专栏收录该内容

9 篇文章

订阅专栏

算法系列：计数排序

2014/08/01 | 分类： IT技术 | 1 条评论 | 标签：排序算法, 算法

分享到： 10

本文由伯乐在线 - 大飞翻译自 austingwalters。未经许可，禁止转载！
欢迎加入：技术翻译小组，或分享原创到伯乐头条。

计数排序可能是最简单的一种排序，它可以被用来对一个列表进行排序，并且是基数排序的一个关键部分。这两者都是被Harold Seward发明的，这篇文章我将解释计数排序并且用C写出来。

计数排序

计数排序非常基础，他的主要目的是对整数排序并且会比普通的排序算法性能更好。例如，输入{1, 3, 5, 2, 1, 4}给计数排序，会输出{1, 1, 2, 3, 4, 5}。这个算法由以下步骤组成：

初始化一个计数数组，大小是输入数组中的最大的数。
遍历输入数组，遇到一个数就在计数数组对应的位置上加一。例如：遇到5，就将计数数组第五个位置的数加一。
把计数数组直接覆盖到输出数组（节约空间）。

例子

输入{3, 4, 3, 2, 1}，最大是4，数组长度是5。

建立计数数组{0, 0, 0, 0}。

遍历输入数组：

{3, 4, 3, 2, 1} -> {0, 0, 1, 0}
{3, 4, 3, 2, 1} -> {0, 0, 1, 1}
{3, 4, 3, 2, 1} -> {0, 0, 2, 1}
{3, 4, 3, 2, 1} -> {0, 1, 2, 1}
{3, 4, 3, 2, 1} -> {1, 1, 2, 1}

计数数组现在是{1, 1, 2, 1}，我们现在把它写回到输入数组里：

{0, 1, 2, 1} -> {1, 4, 3, 2, 1}
{o, o, 2, 1} -> {1, 2, 3, 2, 1}
{o, o, 1, 1} -> {1, 2, 3, 2, 1}
{o, o, o, 1} -> {1, 2, 3, 3, 1}
{o, o, o, o} -> {1, 2, 3, 3, 4}

这样就排好序了。

时间：O(n + k)，n是输入数组长度，k是最大的数的大小。
空间：O(n + k)，n是输入数组长度，k是最大的数的大小。

代码

 
         #include <stdio.h>
        
         #include <stdlib.h>
        
         void 
          printArray(
         int 
          * array, 
         int 
          size){
        
         int 
          curr;
        
         for
         (curr = 0; curr < size; curr++){
        
         printf
         (
         "%d, "
         , array[curr]);
        
         }
        
         printf
         (
         "\n"
         );
        
         }
        
         int 
          maximum(
         int 
          * array, 
         int 
          size){
        
         int 
          curr = 0;
        
         int 
          max = 0;
        
         for
         (curr = 0; curr < size; curr++){
        
         if
         (array[curr] > max){ max = array[curr]; }
        
         }
        
         return 
          max;
        
         }
        
         void 
          countingSort(
         int 
          * array, 
         int 
          size){
        
         int 
          curr = 0;
        
         int 
          max = maximum(array, size);
        
         int 
          * counting_array = 
         calloc
         (max, 
         sizeof
         (
         int
         )); 
         // Zeros out the array
        
         for
         (curr = 0; curr < size; curr ++){
        
         counting_array[array[curr]]++;
        
         }
        
         int 
          num = 0;
        
         curr = 0;
        
         while
         (curr <= size){
        
         while
         (counting_array[num] > 0){
        
         array[curr] = num;
        
         counting_array[num]--;
        
         curr++;
        
         if
         (curr > size){ 
         break
         ; }
        
         }
        
         num++;
        
         }
        
         printArray(array, size);
        
         }
        
         int 
          main(){
        
         int 
          test1[] = {2, 6, 4, 3, 2, 3, 4, 6, 3, 4, 3, 5, 2, 6};
        
         int 
          size1 = 14;
        
         countingSort(test1, size1);
        
         int 
          test2[] = {5, 6, 7, 8, 5};
        
         int 
          size2 = 5;
        
         countingSort(test2, size2);
        
         int 
          test3[] = {8, 1, 2, 3, 3, 4};
        
         int 
          size3 = 6;
        
         countingSort(test3, size3);
        
         return 
          0;
        
         }