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

原创 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个左右。

 

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

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

相关文章推荐

Thrift对多接口服务的支持

Thrift对多接口服务的支持       Thrift在0.9.1版本之前,一直只提交了对单一接口服务的支持,即一个RPC服务器(对应一个端口)支持一个服务接口的实现。 但是很多时候,我们...
  • hivon
  • hivon
  • 2013年09月14日 14:43
  • 18628

【Apache Thrift】Thrift的使用和编译(二)

一、Thrift的使用   1.1基本类型  thrift不支持无符号类型,因为很多编程语言不存在无符号类型,比如javabyte: 有符号字节i16: 16位有符号整数i32: 32位有符号整数i6...

线性排序算法(计数排序,基数排序,桶排序)分析及实现

写在前面 大家都知道的是,基于比较的排序算法的时间复杂度的下界是 O(n log(n))。这一结论是可以证明的,所以在基于比较的算法中是找不到时间复杂度为 O(n)的算法的。这时候,非基于比较的算法...

【算法学习】线性时间排序-计数排序、基数排序和桶排序详解与编程实现

计数排序 计数排序假设n个输入元素中的每一个都是介于0到k之间的整数。此处k为某个整数(输入数据在一个小范围内)。 算法思想 计数排序的基本思想是对每一个输入元素x,...

排序算法(插入排序、shell排序、冒泡排序、选择排序、合并排序、堆排序、快速排序、计数排序、基数排序、桶排序)

排序算法分两种: 1.比较排序,时间复杂度最少达到O(n*lg n),主要有:插入排序,冒泡排序,选择排序,合并排序,堆排序,快速排序等。 2.非比较排序,时间复杂度可以达到O(n),主要有:计数...

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

三种线性排序算法 计数排序、桶排序与基数排序 [非基于比较的排序] 在计算机科学中,排序是一门基础的算法技术,许多算法都要以此作为基础,不同的排序算法有着不同的时间开销和空间开销。排序算法...

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

#include #include #include #include #include using namespace std; class MySort { public: MyS...

八大排序学习之八分配排序(计数排序、桶排序、基数排序}

分配排序,常见的有三种,计数排序和桶排序和基数排序,他们的时间复杂度最好都是O(n) 计数排序、桶排序和基数排序都用了一种方法,把想要排序的数据放到桶子里,再进行排序,这是一种用空间换取效率的方法。 ...

内部排序之五:计数排序、基数排序和桶排序

前言    最后三种排序算法了,由于都不是基于比较的排序,因此这三种排序算法可以以线性时间运行。但是因为限制条件的特殊性,因此应用面没有基于元素比较的排序算法广,但是在很多特定的情况下还是蛮有用...

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

计数排序 当输入的元素是 n 个 0 到 k 之间的整数时,它的运行时间是 Θ(n + k)。计数排序不是比较排序,排序的速度快于任何比较排序算法。 由于用来计数的数组C的长度取决于待排序...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:计数排序、桶排序和基数排序
举报原因:
原因补充:

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