基数排序与桶排序C实现

一. 算法描述

基数排序（以整形为例），将整形10进制按每位拆分，然后从低位到高位依次比较各个位。主要分为两个过程：

(1)分配，先从个位开始，根据位值(0-9)分别放到0~9号桶中（比如53,个位为3，则放入3号桶中）

(2)收集，再将放置在0~9号桶中的数据按顺序放到数组中

重复(1)(2)过程，从个位到最高位（比如32位无符号整形最大数4294967296，最高位10位）

以【521 310 72 373 15 546 385 856 187 147】序列为例，具体细节如下图所示：

在数据中最高位为3，进行了三次分配、收集过程后，变成有序数组。

二. 算法分析

平均时间复杂度：O(dn)(d即表示整形的最高位数)

空间复杂度：O(10n) （10表示0~9，用于存储临时的序列） 

稳定性：稳定

三. 算法实现

[cpp] view plaincopy

1. /******************************************************** 
2. *函数名称：GetNumInPos 
3. *参数说明：num 一个整形数据 
4. *          pos 表示要获得的整形的第pos位数据 
5. *说明：    找到num的从低到高的第pos位的数据 
6. *********************************************************/  
7. int GetNumInPos(int num,int pos)  
8. {  
9.     int temp = 1;  
10.     for (int i = 0; i < pos - 1; i++)  
11.         temp *= 10;  
12.   
13.     return (num / temp) % 10;  
14. }  
15.   
16. /******************************************************** 
17. *函数名称：RadixSort 
18. *参数说明：pDataArray 无序数组； 
19. *          iDataNum为无序数据个数 
20. *说明：    基数排序 
21. *********************************************************/  
22. #define RADIX_10 10    //整形排序  
23. #define KEYNUM_31 31     //关键字个数，这里为整形位数  
24. void RadixSort(int* pDataArray, int iDataNum)  
25. {  
26.     int *radixArrays[RADIX_10];    //分别为0~9的序列空间  
27.     for (int i = 0; i < 10; i++)  
28.     {  
29.         radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));  
30.         radixArrays[i][0] = 0;    //index为0处记录这组数据的个数  
31.     }  
32.       
33.     for (int pos = 1; pos <= KEYNUM_31; pos++)    //从个位开始到31位  
34.     {  
35.         for (int i = 0; i < iDataNum; i++)    //分配过程  
36.         {  
37.             int num = GetNumInPos(pDataArray[i], pos);  
38.             int index = ++radixArrays[num][0];  
39.             radixArrays[num][index] = pDataArray[i];  
40.         }  
41.   
42.         for (int i = 0, j =0; i < RADIX_10; i++)    //收集  
43.         {  
44.             for (int k = 1; k <= radixArrays[i][0]; k++)  
45.                 pDataArray[j++] = radixArrays[i][k];  
46.             radixArrays[i][0] = 0;    //复位  
47.         }  
48.     }  
49. }  

转自：  http://blog.csdn.net/cjf_iceking/article/details/7943609

排序算法——桶排序

      桶排序 (Bucket sort)或所谓的箱排序，是一个排序算法，工作的原理是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。
      例如要对大小为[1..1000]范围内的n个整数A[1..n]排序，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储(10..20]的整数，……集合B[i]存储((i-1)*10, i*10]的整数，i = 1,2,..100。总共有100个桶。然后对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。 然后再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任何排序法都可以。最后依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这样就得到所有数字排好序的一个序列了。   
      假设有n个数字，有m个桶，如果数字是平均分布的，则每个桶里面平均有n/m个数字。如果对每个桶中的数字采用快速排序，那么整个算法的复杂度是O(n+m*n/m*log(n/m))=O(n+nlogn-nlogm)   
      从上式看出，当m接近n的时候，桶排序复杂度接近O(n)   
      当然，以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的，实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中，那就退化成一般的排序了。

Code:

1. #include <stdio.h>   
2. #include <stdlib.h>   
3. #include <string.h>   
4.   
5. extern void quick_sort(int a[], int p, int q);/* not necessary */  
6.   
7. struct barrel {   
8.     int node[10];   
9.     int count;/* the num of node */  
10. };   
11.   
12. void bucket_sort(int data[], int size)   
13. {   
14.     int max, min, num, pos;   
15.     int i, j, k;   
16.     struct barrel *pBarrel;   
17.   
18.     max = min = data[0];   
19.     for (i = 1; i < size; i++) {   
20.         if (data[i] > max) {   
21.             max = data[i];   
22.         } else if (data[i] < min) {   
23.             min = data[i];   
24.         }   
25.     }   
26.     num = (max - min + 1) / 10 + 1;   
27.     pBarrel = (struct barrel*)malloc(sizeof(struct barrel) * num);   
28.     memset(pBarrel, 0, sizeof(struct barrel) * num);   
29.   
30.     /* put data[i] into barrel which it belong to */  
31.     for (i = 0; i < size; i++) {   
32.         k = (data[i] - min + 1) / 10;/* calculate the index of data[i] in barrel */  
33.         (pBarrel + k)->node[(pBarrel + k)->count] = data[i];   
34.         (pBarrel + k)->count++;   
35.     }   
36.        
37.     pos = 0;   
38.     for (i = 0; i < num; i++) {   
39.         quick_sort((pBarrel+i)->node, 0, (pBarrel+i)->count);/* sort node in every barrel */  
40.   
41.         for (j = 0; j < (pBarrel+i)->count; j++) {   
42.             data[pos++] = (pBarrel+i)->node[j];   
43.         }   
44.     }   
45.     free(pBarrel);   
46. }   
47.   
48. main()   
49. {   
50.     int data[] = {78, 17, 39, 26, 72, 94, 21, 12, 23, 91}, i;   
51.     int size = sizeof(data) / sizeof(int);   
52.     bucket_sort(data, size);   
53.   
54.     for (i = 0; i < size; i++)   
55.         printf("%d ", data[i]);  
56. }

1. C++

2. #include <iostream>
   #include <cstdlib>
   #include <cstring>
   using namespace std;
   
   struct barrel
   {
   	int node[30];  //设桶中最多元素的上限
   	int count;		//桶中的真实元素的个数
   };
   int comp(const void *a,const void *b)
   {
   	return *(int *)a-*(int *)b;
   }
   class bucket_sort
   {
   public:
   	bucket_sort();	// 用于初始化数据
   	~bucket_sort(){};
   	void BucketSort();
   	void Output();
   	void SetNumsOfBucket(int numsOfBucket)
   	{
   		Buckets = numsOfBucket;
   	}
   private:
   	int length;
   	int *data;
   	struct Node **head;
   	int Buckets;
   };
   
   void bucket_sort::BucketSort()
   {
   	int dataMax, dataMin, numsOfBucket;
   	dataMax = dataMin = data[0];
   	for(int i = 0; i < length; i++)
   	{
   		if(dataMax < data[i])
   			dataMax = data[i];
   		if(dataMin > data[i])
   			dataMin = data[i];
   	}
   	numsOfBucket = (dataMax - dataMin + 1)/10 + 1;	 // 桶的个数
   	SetNumsOfBucket(numsOfBucket);
   	struct barrel *pBarrel = new struct barrel[numsOfBucket];
   	memset(pBarrel, 0, sizeof(struct barrel) * numsOfBucket);
   	for (int i = 0; i < length; i++)
   	{
   		int k = (data[i] - dataMin + 1)/10;
   		(pBarrel + k)->node[(pBarrel + k)->count] = data[i];
   		(pBarrel + k)->count++;
   	}
   	int pos_tmp = 0;
   	for (int i = 0; i < numsOfBucket; i++)
   	{
   		qsort((pBarrel + i)->node, (pBarrel + i)->count, sizeof(int), comp);
   		for (int j = 0; j < (pBarrel + i)->count; j++)
   			data[pos_tmp++] = (pBarrel + i)->node[j];
   	}
   	delete [] pBarrel;
   }
   
   bucket_sort::bucket_sort()
   {
   	cout << "输入原始数据的个数： " ;
   	cin >> length;
   	data = new int[length];
   	cout << "输入数据："<<endl;
   	for (int i = 0; i < length; i++)
   		cin >> data[i];
   }
   
   void bucket_sort::Output()
   {
   	cout << "数据为： ";
   	for (int i = 0; i < length; i++)
   		cout << data[i] << " ";
   	cout << endl;
   }
   
   void main()
   {
   	bucket_sort Test;
   	Test.Output();
   	Test.BucketSort();
   	Test.Output();
   }