计数排序、桶排序和基数排序

原创 2016年08月30日 16:31:54

计数排序

当输入的元素是 n 个 0 到 k 之间的整数时,它的运行时间是 Θ(n + k)。计数排序不是比较排序,排序的速度快于任何比较排序算法。

由于用来计数的数组C的长度取决于待排序数组中数据的范围(等于待排序数组的最大值与最小值的差加上1),这使得计数排序对于数据范围很大的数组,需要大量时间和内存。例如:计数排序是用来排序0到100之间的数字的最好的算法,但是它不适合按字母顺序排序人名。但是,计数排序可以用在基数排序中的算法来排序数据范围很大的数组。

算法的步骤如下:

  1. 找出待排序的数组中最大和最小的元素
  2. 统计数组中每个值为i的元素出现的次数,存入数组C的第i
  3. 对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加)
  4. 反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1

贴上代码:

[html] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <time.h>  
  4.   
  5. //对于排序的关键字范围,一定是0-99  
  6. #define NUM_RANGE (100)  
  7.   
  8. void print_arr(int *arr, int n)  
  9. {  
  10.        int i;  
  11.        for(i=0; i<n; i++){  
  12.                if(!i){  
  13.                        printf("%d", arr[i]);  
  14.                }else{  
  15.                        printf(" %d", arr[i]);  
  16.                }  
  17.        }  
  18.        printf("\n");  
  19. }  
  20.   
  21. /*  
  22. 算法的步骤如下:  
  23.     1.找出待排序的数组中最大和最小的元素  
  24.     2.统计数组中每个值为i的元素出现的次数,存入数组C的第i项  
  25.     3.对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加)  
  26.     4.反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1  
  27. */  
  28.   
  29. void counting_sort(int *ini_arr, int *sorted_arr, int n)  
  30. {  
  31.        int *count_arr = (int *)malloc(sizeof(int) * NUM_RANGE);  
  32.        int i, j, k;  
  33.   
  34.        //统计数组中,每个元素出现的次数  
  35.        for(k=0; k<NUM_RANGE; k++){  
  36.                count_arr[k] = 0;  
  37.        }  
  38.          
  39.        for(i=0; i<n; i++){  
  40.                count_arr[ini_arr[i]]++;  
  41.        }  
  42.   
  43.   
  44.        for(k=1; k<NUM_RANGE; k++){  
  45.                count_arr[k] += count_arr[k-1];  
  46.        }  
  47.   
  48.        for(j=n-1 ; j>=0; j--){  
  49.            int elem = ini_arr[j];  
  50.            int index = count_arr[elem]-1;  
  51.            sorted_arr[index] = elem;  
  52.            count_arr[elem]--;  
  53.        }  
  54.        free(count_arr);  
  55. }  
  56.   
  57.   
  58. int main(int argc, char* argv[])  
  59. {  
  60.        int n;  
  61.        if(argc < 2){  
  62.                n = 10;  
  63.        }else{  
  64.                n = atoi(argv[1]);  
  65.        }  
  66.        int i;  
  67.        int *arr = (int *)malloc(sizeof(int) * n);  
  68.        int *sorted_arr = (int *)malloc(sizeof(int) *n);  
  69.        srand(time(0));  
  70.   
  71.          
  72.        for(i=0; i<n; i++){  
  73.                arr[i] = rand() % NUM_RANGE;  
  74.        }  
  75.   
  76.        printf("ini_array: ");  
  77.        print_arr(arr, n);  
  78.        counting_sort(arr, sorted_arr, n);  
  79.        printf("sorted_array: ");  
  80.        print_arr(sorted_arr, n);  
  81.        free(arr);  
  82.        free(sorted_arr);  
  83.        return 0;  
  84. }  


 桶排序:http://blog.sina.com.cn/s/blog_667739ba0100veth.html

桶排序的基本思想

假设有一组长度为N的待排关键字序列K[1....n]。首先将这个序列划分成M个的子区间(桶) 。然后基于某种映射函数 ,将待排序列的关键字k映射到第i个桶中(即桶数组B的下标 i) ,那么该关键字k就作为B[i]中的元素(每个桶B[i]都是一组大小为N/M的序列)。接着对每个桶B[i]中的所有元素进行比较排序(可以使用快排)。然后依次枚举输出B[0]....B[M]中的全部内容即是一个有序序列。

假如待排序列K= {49、 38 、 35、 97 、 76、 73 、 27、 49 }。这些数据全部在1—100之间。因此我们定制10个桶,然后确定映射函数f(k)=k/10。则第一个关键字49将定位到第4个桶中(49/10=4)。依次将所有关键字全部堆入桶中,并在每个非空的桶中进行快速排序。

桶排序代价分析

桶排序利用函数的映射关系,减少了几乎所有的比较工作。实际上,桶排序的f(k)值的计算,其作用就相当于快排中划分,已经把大量数据分割成了基本有序的数据块(桶)。然后只需要对桶中的少量数据做先进的比较排序即可。

 

对N个关键字进行桶排序的时间复杂度分为两个部分:

(1) 循环计算每个关键字的桶映射函数,这个时间复杂度是O(N)。

(2) 利用先进的比较排序算法对每个桶内的所有数据进行排序,其时间复杂度为 ∑ O(Ni*logNi) 。其中Ni 为第i个桶的数据量。

 

很显然,第(2)部分是桶排序性能好坏的决定因素。尽量减少桶内数据的数量是提高效率的唯一办法(因为基于比较排序的最好平均时间复杂度只能达到O(N*logN)了)。因此,我们需要尽量做到下面两点:

(1) 映射函数f(k)能够将N个数据平均的分配到M个桶中,这样每个桶就有[N/M]个数据量。

(2) 尽量的增大桶的数量。极限情况下每个桶只能得到一个数据,这样就完全避开了桶内数据的“比较”排序操作。 当然,做到这一点很不容易,数据量巨大的情况下,f(k)函数会使得桶集合的数量巨大,空间浪费严重。这就是一个时间代价和空间代价的权衡问题了。

 

对于N个待排数据,M个桶,平均每个桶[N/M]个数据的桶排序平均时间复杂度为:

O(N)+O(M*(N/M)*log(N/M))=O(N+N*(logN-logM))=O(N+N*logN-N*logM)

当N=M时,即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。

 

总结: 桶排序的平均时间复杂度为线性的O(N+C),其中C=N*(logN-logM)。如果相对于同样的N,桶数量M越大,其效率越高,最好的时间复杂度达到O(N)。 当然桶排序的空间复杂度 为O(N+M),如果输入数据非常庞大,而桶的数量也非常多,则空间代价无疑是昂贵的。此外,桶排序是稳定的。

我个人还有一个感受:在查找算法中,基于比较的查找算法最好的时间复杂度也是O(logN)。比如折半查找、平衡二叉树、红黑树等。但是Hash表却有O(C)线性级别的查找效率(不冲突情况下查找效率达到O(1))。大家好好体会一下:Hash表的思想和桶排序是不是有一曲同工之妙呢?

基数排序

上面的问题是多关键字的排序,但单关键字也仍然可以使用这种方式。

比如字符串“abcd” “aesc” "dwsc" "rews"就可以把每个字符看成一个关键字。另外还有整数 425、321、235、432也可以每个位上的数字为一个关键字。

 

基数排序的思想就是将待排数据中的每组关键字依次进行桶分配。比如下面的待排序列:

278、109、063、930、589、184、505、269、008、083

我们将每个数值的个位,十位,百位分成三个关键字: 278 -> k1(个位)=8 ,k2(十位)=7 ,k3=(百位)=2。

然后从最低位个位开始(从最次关键字开始),对所有数据的k1关键字进行桶分配(因为,每个数字都是 0-9的,因此桶大小为10),再依次输出桶中的数据得到下面的序列。

930、063、083、184、505、278、008、109、589、269

再对上面的序列接着进行针对k2的桶分配,输出序列为:

505、008、109、930、063、269、278、083、184、589

最后针对k3的桶分配,输出序列为:

008、063、083、109、184、269、278、505、589、930

 

性能分析

很明显,基数排序的性能比桶排序要略差。每一次关键字的桶分配都需要O(N)的时间复杂度,而且分配之后得到新的关键字序列又需要O(N)的时间复杂度。假如待排数据可以分为d个关键字,则基数排序的时间复杂度将是O(d*2N) ,当然d要远远小于N,因此基本上还是线性级别的。基数排序的空间复杂度为O(N+M),其中M为桶的数量。一般来说N>>M,因此额外空间需要大概N个左右。

 

但是,对比桶排序,基数排序每次需要的桶的数量并不多。而且基数排序几乎不需要任何“比较”操作,而桶排序在桶相对较少的情况下,桶内多个数据必须进行基于比较操作的排序。因此,在实际应用中,基数排序的应用范围更加广泛。

版权声明:本文为博主原创文章,未经博主允许不得转载。

Java排序算法以及算法改进总结(计数排序、基数排序、桶排序)

算法复习,代码是最好的说明! 一、计数排序: 算法: 统计数组A中每个值A[i]出现的次数,存入C[A[i]] 从前向后,使数组C中的每个值等于其与前一项相加,这样数组C[A[i]]就变成了代...
  • poyuan97
  • poyuan97
  • 2017年10月16日 20:17
  • 61

计数排序和基数排序和桶排序

本文转载于:http://www.cnblogs.com/kkun/archive/2011/11/23/2260299.html 经典排序算法 - 计数排序Counting sort 经典排序...
  • msdnwolaile
  • msdnwolaile
  • 2016年09月07日 14:46
  • 464

UVA11462 Age Sort【基数排序/桶排序/计数排序】

You are given the ages (in years) of all people of a country with at least 1 year of age. You know t...
  • tigerisland45
  • tigerisland45
  • 2018年01月10日 16:51
  • 178

三种线性排序算法: 计数排序、桶排序与基数排序

[非基于比较的排序]在计算机科学中,排序是一门基础的算法技术,许多算法都要以此作为基础,不同的排序算法有着不同的时间开销和空间开销。排序算法有非常多种,如我们最常用的快速排序和堆排序等算法,这些算法需...
  • gao1440156051
  • gao1440156051
  • 2016年05月12日 17:32
  • 293

计数排序和桶排序

介绍两种非基于比较的排序算法。前面提到的排序算法,快排,堆排,合并等都是通过比较元素之间的大小来进行排序的,基于比较的排序是不能突破NLog2NNLog_2N的下界的。而这两种算法的时间复杂度是可以达...
  • u013220338
  • u013220338
  • 2015年04月12日 22:51
  • 382

桶排序和计数排序

桶排序和计数排序 桶排序 (Bucket sort)或所谓的箱排序,是一个排序算法,工作的原理是将阵列分到有限数量的桶子里。每个桶子再个别排序(有可能再使用别的排序算法或是以递回方式继续使用桶排...
  • tiantangrenjian
  • tiantangrenjian
  • 2012年01月03日 15:26
  • 2769

桶排序和基数排序 Java

桶式排序 概念 有限个数字m,每个数字的大小都在1与n之间,则我们可以假设有n个桶,遍历m个数字,将其存入对应的桶中(如数字的值为3,就存入3号桶,桶的值对应存入数字的个数) 例子 有数字3,3,5,...
  • u011863767
  • u011863767
  • 2016年12月28日 19:36
  • 579

桶排序 基数排序

桶排序和基数排序,在今天和同学讨论中听到,完全不懂,后来经过查阅,将这两种算法的综述性介绍汇总如下: 桶排序和基数排序是从分配排序演进的,大致的顺序是分配排序-桶排序-基数排序。 通过下面的阐述可...
  • u013279509
  • u013279509
  • 2015年04月22日 23:19
  • 1054

排序算法之线性排序(计数排序和桶排序)--Java语言

之前的文章讲到的都是比较算法,以下链接是之前文章提到过的一些基本排序方法,其时间复杂度的下界是O(nlogn)。今天提到的两个主角分别是计数排序和桶排序,其时间复杂度好的情况下能够达到O(n),它们不...
  • carson0408
  • carson0408
  • 2017年11月28日 15:19
  • 630

线性排序算法(计数排序和桶排序) C++

前言: 比较排序的下界为o(nlogn)。那么有没有时间复杂度为o(n)的线性时间排序算法呢?在一定的假设条件下,是有更快的排序算法的,下面介绍的计数排序和桶排序等都是线性时间排序算法。 1、计数排序...
  • u013949069
  • u013949069
  • 2017年05月17日 15:59
  • 363
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:计数排序、桶排序和基数排序
举报原因:
原因补充:

(最多只允许输入30个字)