参考https://blog.csdn.net/quietwave/article/details/8008572
https://www.cnblogs.com/jingmoxukong/p/4311237.html
https://www.cnblogs.com/jztan/p/5878630.html
基数排序 vs 计数排序 vs 桶排序
这三种排序算法都利用了桶的概念,但对桶的使用方法上有明显差异:
- 基数排序:根据键值的每位数字来分配桶
- 计数排序:每个桶只存储单一键值
- 桶排序:每个桶存储一定范围的数值
当输入的元素是 n 个 0 到 k 之间的整数时,它的运行时间是 Θ(n + k)。计数排序不是比较排序,排序的速度快于任何比较排序算法。
由于用来计数的数组C的长度取决于待排序数组中数据的范围(等于待排序数组的最大值与最小值的差加上1),这使得计数排序对于数据范围很大的数组,需要大量时间和内存。例如:计数排序是用来排序0到100之间的数字的最好的算法,但是它不适合按字母顺序排序人名。但是,计数排序可以用在基数排序中的算法来排序数据范围很大的数组。
算法的步骤如下:
- 找出待排序的数组中最大和最小的元素
- 统计数组中每个值为i的元素出现的次数,存入数组C的第i项
- 对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加)
- 反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1
桶排序的基本思想
假设有一组长度为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个左右。
但是,对比桶排序,基数排序每次需要的桶的数量并不多。而且基数排序几乎不需要任何“比较”操作,而桶排序在桶相对较少的情况下,桶内多个数据必须进行基于比较操作的排序。因此,在实际应用中,基数排序的应用范围更加广泛。
计数排序
#include<iostream> void CountingSort(int a[], int n, int k); int main() { int a[] = { 1,45,34,65,12,43,10,67,5,78,10,3,70,40 }; //int a[] = { 2,5,3,0,2,3,0,3 }; int len = sizeof(a) / sizeof(a[0]); int max = a[0]; for (int i = 1; i < len; i++) { if (a[i] > max) max = a[i]; } //std::cout << len << ", " << max << std::endl; CountingSort(a, len, max); system("pause"); } void CountingSort(int a[], int n, int k) //n个输入元素,每个都是0-k区间的一个整数 { int *c = new int[k + 1]; int *b = new int[n]; for (int i = 0; i < k + 1; i++) c[i] = 0; for (int j = 0; j < n; j++) c[a[j]] = c[a[j]] + 1; //共有c[a[j]]个数与a[j]相同 for (int i = 1; i < k + 1; i++) c[i] = c[i] + c[i - 1]; //小于等于a[j]的数共有c[i]个 for (int j = 0; j < n; j++) { b[c[a[j]] - 1] = a[j]; c[a[j]] = c[a[j]] - 1; } for (int i = 0; i < n; i++) std::cout << b[i] << " "; delete []c; delete []b; }
桶排序
#include<iostream> #include<vector> using namespace std; struct Node { int val; Node *next; }; //void printnode(Node *p) //{ // Node *h = p; // cout << "print val: "; // while (h) // { // cout << h->val << " "; // h = h->next; // } // cout << endl; //} void BucketSort(vector<int>a, int bucket_size) { Node **bucket_table = (Node **)malloc(bucket_size * sizeof(Node *)); for (int i = 0; i < bucket_size; i++) { bucket_table[i] = (Node *)malloc(sizeof(Node)); bucket_table[i]->val = 0; //记录当前桶中的数据量 bucket_table[i]->next = NULL; } for (int i = 0; i < a.size(); i++) { Node *pnode = (Node *)malloc(sizeof(Node)); pnode->val = a[i]; pnode->next = NULL; int index = a[i] / 10; //映射函数计算桶号 Node *p = bucket_table[index]; //每次循环p都指向桶中数据链表的头指针,初始bucket_table[i]->val=0即p->val=0 if (p->val == 0) { bucket_table[index]->next = pnode; (bucket_table[index]->val)++; //桶中的数据量+1 //printnode(p); } else { while (p->next != NULL && p->next->val <= pnode->val) p = p->next; //printnode(p); pnode->next = p->next; p->next = pnode; (bucket_table[index]->val)++; } } for (int i = 0; i < bucket_size; i++) { cout << "bucket " << i << ": "; for (Node *k = bucket_table[i]->next; k != NULL; k = k->next) cout << k->val << " "; cout << endl; } cout << endl; cout << "after sort: "; for (int i = 0; i < bucket_size; i++) { for (Node *k = bucket_table[i]->next; k != NULL; k = k->next) cout << k->val << " "; } cout << endl; } int main() { vector<int>a = { 49,38,65,97,76,13,47,46,27,34,43 }; cout << "befor sort: "; for (int i = 0; i < a.size(); i++) cout << a[i] << " "; cout << endl << endl; BucketSort(a, 10); system("pause"); }
基数排序
#include<iostream> #include<vector> using namespace std; //在用数组int num[]和C++的vector传递地址时,vector需要传引用,否则,没法得到正确地址, //因为vector本质上是一个类对象,因此传值会得不到正确结果,而数组会退化为指针,因此可以直接传值. int MaxBit(vector<int> &data, int n) { int maxBit = 1; int temp = 10; for (int i = 0; i < n; ++i) { while (data[i] >= temp) { temp *= 10; ++maxBit; } } return maxBit; } //基数排序 void RadixSort(vector<int> &data, int n) { int maxBit = MaxBit(data, n); int* tmpData = new int[n]; int* cnt = new int[10]; //桶中数据个数 int radix = 1; int i, j, binNum; for (i = 1; i <= maxBit; i++) { for (j = 0; j < 10; ++j) cnt[j] = 0; for (j = 0; j < n; j++) { binNum = (data[j] / radix) % 10; cnt[binNum]++; //统计各个桶要装入的数据个数 } for (binNum = 1; binNum< 10; binNum++) cnt[binNum] = cnt[binNum - 1] + cnt[binNum]; //cnt[binNum]表示各个桶的右边界索引 for (j = n - 1; j >= 0; j--) //这里要从右向左扫描,保证排序稳定性 { binNum = (data[j] / radix) % 10; //求出关键码的第k位的数字, 例如:576的第3位是5 tmpData[cnt[binNum] - 1] = data[j]; //放入对应的桶中,count[binNum]-1是第binNum个桶的右边界索引 cnt[binNum]--; //对应桶的装入数据索引-1 } for (j = 0; j < n; j++) data[j] = tmpData[j]; //将已分配好的桶中数据再倒出来,此时已是对应当前位数有序的表 radix = radix * 10; } delete[] tmpData; delete[] cnt; } int main() { vector<int> data = { 73, 22, 93, 43, 156, 356, 55, 14, 28, 65, 39, 81 }; //vector<int> data = { 73, 2, 14, 32 }; int len = data.size(); cout << "Radix Sort" << endl; cout << "before sort:"; for (int i = 0; i < len; i++) cout << data[i] << " "; cout << endl; RadixSort(data, len); cout << "after sort:"; for (int i = 0; i < len; i++) cout << data[i] << " "; cout << endl; system("pause"); return 0; }