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

线性时间排序

计数排序

          计数排序的前提是确定输入范围大小为0～k。在这个前提下，我们可以使用计数的方法对数组进行排序，而不是使用比较。算法思想如下：因为输入数组a[]中的元素范围固定，因此可以使用一个大小为k的数组c对a中的元素进行映射。

          1.如果输入a为i,则使得c[i]++，表示元素i输入的次数。对数组a遍历一次后，就会根据元素i的大小映射到数组c中。

          2.对数组c中的数据进行统计，算出在元素i之前有多少个比i小的数据。遍历数组c一次后，c[i]对应的是元素i在原数组a中排列的第一个位置。

          3.使用位置关系数组c，将a数组逐一放到数组b的相应位置中。遍历a数组一遍后，则此时b数组为a数组排序好的版本。

         因此算法复杂度为o(n+k)

基数排序

       基数排序是将一个数分成几个部分，分别从后往前将每部分排序，其他部分作为卫星数据连带进行排序。

       对于整数而言，因为每一位的大小都是0～9，因此可以对每一次使用计数排序，从而对任意整数进行排序。

       假设需要排序的数位数d，因此如果对每一位都使用计数排序的话，总的时间复杂度为o(dn)

桶排序

      假设输入是在区间[0~1)之间的随机数，因此对n个这样的随机数分别放入乘以n后的桶中，接着对每一个桶都分别进行排序，然后按照顺序将桶里面的元素依次输出则得到排序后的结果。

     因为对每个桶进行快速排序用时是分桶长度的平方，因此总的时间复杂度为

                      

       进一步分析可得时间复杂度的期望为o(n)

全部代码如下：

[cpp] view plain copy

1. #include<stdio.h>  
2. #include<algorithm>  
3. #include<math.h>  
4. using namespace std;  
5. int a[100];  
6. int b[100];  
7. int c[100];  
8. //定义桶对象  
9. class Bucket{  
10. public:  
11.     float d;  
12.     Bucket* next;  
13.     Bucket(){}  
14.     Bucket(float d){  
15.         this->d=d;  
16.     }  
17. }*bucket[11];  
18. //计数排序  
19. void conunting_sort(int *a, int *b, int k, int len){  
20.     //初始化c数组  
21.     for(int i=1; i<=k; i++)  
22.       c[k]=0;  
23.     //对a中元素出现次数的统计  
24.     for(int j=1; j<=len; j++)  
25.       c[a[j]]++;  
26.     //对c进行累加，得到位置信息  
27.     for(int x=1; x<=k; x++)  
28.       c[x]+=c[x-1];  
29.     //使用位置信息顺序重建数组  
30.     for(int y=len; y>=1; y--){  
31.         b[c[a[y]]]=a[y];  
32.         c[a[y]]--;  
33.     }  
34.     for(int z=1; z<=len; z++){  
35.         a[z]=b[z];  
36.     }  
37. }  
38.   
39. void exchange(char** str,int j){  
40.     char* tmp;  
41.     tmp=str[j];  
42.     str[j]=str[j+1];  
43.     str[j+1]=tmp;  
44. }  
45. //对基数排序中的每趟排序使用冒泡排序  
46. void char_bubble_sort(char** str,int d, int len){  
47.     for(int i=0; i<len; i++)  
48.       for(int j=0; j<len-1; j++){  
49.         if(str[j][d]>str[j+1][d]){  
50.             exchange(str,j);  
51.         }  
52.       }  
53. }  
54. //基数排序  
55. void radix_sort(char** str, int d, int len){  
56.     for(int i=d-1; i>=0; i--){  
57.         char_bubble_sort(str,i,len);  
58.     }  
59. }  
60. //对桶排序的每趟使用冒泡排序  
61. void link_bubble_sort(Bucket* buck){  
62.     Bucket *t,*tn;  
63.     float s;  
64.     for(Bucket* p=buck; p->next!=NULL; p=p->next){  
65.         for(Bucket* q=buck; q->next->next!=NULL; q=q->next){  
66.             if(q->next->d > q->next->next->d){  
67.                 s=q->next->next->d;  
68.                 q->next->next->d=q->next->d;  
69.                 q->next->d=s;  
70.             }  
71.         }  
72.     }  
73. }  
74. //桶排序  
75. void bucket_sort(float *a, int len){  
76.     //分桶  
77.     for(int i=0; i<len; i++){  
78.         Bucket *p;  
79.         for(p=bucket[int(11*a[i])]; p->next!=NULL; p=p->next);  
80.         p->next=new Bucket(a[i]);          
81.     }  
82.     //没个桶内进行排序  
83.     for(int j=0; j<len; j++){  
84.         link_bubble_sort(bucket[j]);  
85.     }  
86.     for(int k=0; k<len; k++){  
87.         for(Bucket *q=bucket[k]; q->next!=NULL; q=q->next){  
88.             printf("%.2f ",q->next->d);  
89.         }  
90.     }  
91.     printf("\n");  
92. }  
93.   
94. int main(){  
95.     int len;  
96. //  char* str[16]={"COW","DOG","SEA","RUG","ROW","MOB","BOX","TAB","BAR","EAR","TAR","DIG","BIG","TEA","NOW","FOX"};  
97. /*  scanf("%d",&len); 
98.     for(int i=1; i<=len; i++){ 
99.         scanf("%d",&a[i]); 
100.     } 
101.     conunting_sort(a,b,len,len); 
102.     for(int j=1; j<=len; j++){ 
103.         if(j!=len) 
104.             printf("%d ",a[j]); 
105.         else 
106.           printf("%d\n",a[j]); 
107.     }*/  
108.     float a[11]={0.21,0.12,0.39,0.72,0.94,0.78,0.17,0.23,0.26,0.68,0.11};  
109.     for(int z=0; z<11; z++){  
110.         bucket[z]=new Bucket();  
111.     }  
112.     bucket_sort(a,11);  
113. //  radix_sort(str,3,16);  
114. /*  for(int k=0; k<16; k++){ 
115.         if(k!=15) 
116.           printf("%s ",str[k]); 
117.         else 
118.           printf("%s\n",str[k]); 
119.     } 
120. */    
121.     return 0;  
122. }  

 

http://blog.csdn.net/lawrencesgj/article/details/8073375