count sort, radix sort, bucket sort

標(biāo)簽（空格分隔）： algorithms

---

基于比較的排序算法，都逃不過$O(nlogn)$的宿命¹。而非基于比較的排序，如計(jì)數(shù)排序，基數(shù)排序，桶排序則無此限制。它們充分利用待排序的數(shù)據(jù)的某些限定性假設(shè)，來避免絕大多數(shù)的“比較”操作。

計(jì)數(shù)排序

http://www.geeksforgeeks.org/counting-sort/

時(shí)間復(fù)雜度：$O(N+K)$,N為元素個(gè)數(shù)，K為元素最大值。是一種穩(wěn)定的排序算法。

但是我覺得時(shí)間復(fù)雜度其實(shí)還是$O(N)$，因?yàn)椴还苁怯?jì)數(shù)還是最后把每個(gè)元素放入正確的位置都是$O(N)$。

#include <string> #include <vector> #include <iostream>using namespace std;/* O(n+k) 最后count數(shù)組相當(dāng)于往后移了一個(gè)元素。 */void count_sort(string &s) {const int range = 255;vector<int> count(range+1,0);for (auto c : s)count[c]++;for (int i = 1; i <= range; i++)count[i] += count[i-1];string temp(s.size(), ' ');//如果改成從右到左循環(huán)，則是穩(wěn)定的。//當(dāng)然還有一種做法，即不用累加count數(shù)組，直接掃描count數(shù)組，設(shè)置一個(gè)全局index,這樣會(huì)有問題：不穩(wěn)定。但改成從右到左循環(huán)，還是穩(wěn)定的。/*for (int i = s.size()-1; i >= 0; i--){temp[count[s[i]] = s[i];count[s[i]]--;}*/for (auto c : s){temp[count[c]-1] = c;count[c]--;}s = temp;}int main() {string s = "geeksforgeeks";count_sort(s);cout << s << endl; }

基數(shù)排序

http://www.geeksforgeeks.org/radix-sort/
http://notepad.yehyeh.net/Content/Algorithm/Sort/Radix/Radix.php

基數(shù)排序的底層排序可以用計(jì)數(shù)排序或者桶排序。

Let there be $d$ digits in input integers. Radix Sort takes $O(d?(n+b))$ time where $b$ is the base for representing numbers, for example, for decimal system, $b$ is 10. What is the value of $d$? If $k$ is the maximum possible value, then $d$ would be $O(lo{g}_b(k))$. （比如k=1000,b=10,則d=3）So overall time complexity is $O((n+b)?lo{g}_b(k))$. Which looks more than the time complexity of comparison based sorting algorithms for a large $k$. Let us first limit $k$. Let $k<=n^c$ where $c$ is a constant. In that case, the complexity becomes $O(nlo{g}_b(n))$. But it still doesn’t beat comparison based sorting algorithms.

What if we make value of $b$ larger?. What should be the value of $b$
to make the time complexity linear? If we set $b$ as $n$, we get the
time complexity as $O(n)$. In other words, we can sort an array of
integers with range from 1 to $n^c$ if the numbers are represented in
base $n$ (or every digit takes $lo{g}_2(n)$ bits).

上面最后一段說，如果要給$1$~$n^c$之內(nèi)的以$n$為基數(shù)的數(shù)組排序，那么就可以用線性的復(fù)雜度完成。

問題：對(duì)$[0,n^2?1]$的$n$ 個(gè)整數(shù)進(jìn)行線性時(shí)間排序。
方法¹是先把整數(shù)轉(zhuǎn)換成n進(jìn)制再排序，這樣每個(gè)數(shù)有兩位，范圍為[0…n-1],再進(jìn)行基數(shù)排序。http://blog.csdn.net/mishifangxiangdefeng/article/details/7685839

#include <string> #include <algorithm> #include <vector> #include <iostream>using namespace std;void countSort(vector<int>& nums, int exp) {int sz = nums.size();vector<int> output(sz, 0);vector<int> count(10, 0);for (auto n : nums)count[(n/exp)%10]++;//count[i]表示i前面有count[i]個(gè)數(shù)字。i處填nums[count[i]]for (int i = 1; i < 10; i++)count[i] += count[i-1];//從后面開始放nums，穩(wěn)定的排序for (int i = sz-1; i >= 0; i--){output[count[(nums[i]/exp)%10]-1] = nums[i];count[(nums[i]/exp)%10]--;}nums = output; }void radix_sort(vector<int>& nums) {int m = *max_element(nums.begin(), nums.end());for (int exp = 1; m/exp > 0; exp *= 10)countSort(nums, exp); }int main() {int arr[] = {170, 45, 75, 90, 802, 24, 2, 66};vector<int> test(arr, arr+sizeof(arr)/sizeof(int));radix_sort(test);for (auto r : test)cout << r << " ";cout << endl;}

LSD:從關(guān)鍵字優(yōu)先級(jí)低的開始排，循環(huán)
MSD：從關(guān)鍵字優(yōu)先級(jí)高的開始排，遞歸

lsd適合于定長的字符串?dāng)?shù)組排序：

void lsd(vector<string>& sVec) {const int N = 256+1;int w = sVec[0].length();int sz = sVec.size();for (int d = w-1; d >= 0; d--){vector<int> count(N, 0);vector<string> temp(N, "");for (int i = 0; i < sz; i++)count[sVec[i][d]+1]++;for (int i = 1; i < N; i++)count[i] += count[i-1];for (int i = 0; i < sz; i++){temp[count[sVec[i][d]]] = sVec[i];count[sVec[i][d]]++;}for (int i = 0; i < sz; i++)sVec[i] = temp[i]; } }int main() {//lsdstring s1[] = {"dab","add","cab","fab","fee","bad","dad","bee","fed","bed","ebb","ace"};vector<string> test1(s1, s1+sizeof(s1)/sizeof(string));msd(test1);for (auto r : test1)cout << r << endl; }

下面是程序中的count計(jì)數(shù)方法：
vector sVec: aab, bba, baa。
計(jì)的是count[sVec[i][d]+1]++；所以計(jì)數(shù)如下：

| 0 | …… | ‘a(chǎn)’ | ‘b’ | ‘c’ |
|:----?:----?:----?:----?
| 0 | …… | 0 | 1 | 2 |

第一輪排序（即按第一個(gè)字符排序）按count數(shù)組將string放置到正確的位置：
aab放到[0]，‘a(chǎn)’$\rightarrow$1bba放到[1]{，}^{\prime }{b}^{\prime }$\rightarrow$2baa放到[2]{，}^{\prime }{b}^{\prime }$\rightarrow$2

0……‘a(chǎn)’‘b’‘c’

0	……	1	3	2

……然后以這種方法分別對(duì)第2個(gè)，第3個(gè)字符排序。

下面用msd的方法對(duì)一個(gè)字符串?dāng)?shù)組進(jìn)行按字典序排列。

根據(jù)首字母將數(shù)組分成R部分，使用counting sort。

遞歸地對(duì)這R部分使用counting sort。（為了使待排序的字符串的長度不固定，可以統(tǒng)計(jì)字符串結(jié)束時(shí)候的’\0’，并且遞歸地時(shí)候，直接略過該字符串。）

#include <vector> #include <iostream> #include <string>using namespace std;//lo~hi表示待排序的字符串為sVec[lo, hi-1]。 void msd(vector<string>& sVec, int lo, int hi, int pos) {const int N = 256+1;if (hi <= lo+1) return;vector<int> count(N, 0);vector<string> temp(hi-lo, "");int sz = sVec.size();//這和一般的count sort計(jì)法略有不同。整體往后移了一位for (int i = lo; i < hi; i++)count[sVec[i][pos]+1]++;for (int i = 1; i < N; i++)count[i] += count[i-1];//這里雖然是從前往后放置，但是仍然是穩(wěn)定的。因?yàn)榍懊娴挠?jì)數(shù)的時(shí)候，計(jì)的是count[sVec[i][pos]+1]，但是旋轉(zhuǎn)的時(shí)候，是從count[sVec[i][pos]]開始放的。for (int i = lo; i < hi; i++){temp[count[sVec[i][pos]]] = sVec[i];count[sVec[i][pos]]++; //相當(dāng)于把count數(shù)組往前移了一個(gè)元素}for (int i = lo; i < hi; i++)sVec[i] = temp[i-lo];for (int i = 1; i < N-1; i++)msd(sVec, lo+count[i], lo+count[i+1], pos+1); //count[i]~count[i+1]相當(dāng)于對(duì)索引為i的元素排序。 }void msd(vector<string>& sVec) {msd(sVec, 0, sVec.size(), 0); }int main() {string s[] = {"dabggg","adda","cabeu","fab","fee","bad","dad","bee","fed","bed","ebb","ace"};vector<string> test(s, s+sizeof(s)/sizeof(string));msd(test);for (auto r : test)cout << r << endl; }

桶排序

http://www.geeksforgeeks.org/bucket-sort-2/

#include <vector> #include <iostream> #include <algorithm>using namespace std;void bucket_sort(vector<double>& nums) {vector<vector<double>> bucket(10, vector<double>(0));for (auto num : nums)bucket[10*num].push_back(num);for (int i = 0; i < 10; i++)sort(bucket[i].begin(), bucket[i].end());int index = 0;//10個(gè)桶for (int i = 0; i < 10; i++){for (int j = 0; j < bucket[i].size(); j++) nums[index++] = bucket[i][j];} }int main() {double arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};vector<double> test(arr, arr+sizeof(arr)/sizeof(double));bucket_sort(test);for (auto r : test)cout << r << " ";cout << endl; }

對(duì)該算法簡單分析，如果數(shù)據(jù)是期望平均分布的，則每個(gè)桶中的元素平均個(gè)數(shù)為N/M。如果對(duì)每個(gè)桶中的元素排序使用的算法是快速排序，每次排序的時(shí)間復(fù)雜度為O(N/Mlog(N/M))。則總的時(shí)間復(fù)雜度為O(N)+O(M)O(N/Mlog(N/M)) = O(N+ Nlog(N/M)) = O(N + NlogN - NlogM)。當(dāng)M接近于N是，桶排序的時(shí)間復(fù)雜度就可以近似認(rèn)為是O(N)的。就是桶越多，時(shí)間效率就越高，而桶越多，空間卻就越大，由此可見時(shí)間和空間是一個(gè)矛盾的兩個(gè)方面¹。
¹:https://www.byvoid.com/blog/sort-radix

平均復(fù)雜度為$O(n)$：將元素放入桶中$O(n)$，收集元素$O(n)$，sort平均$O(n)$。

#reference
http://segmentfault.com/a/1190000003054515#articleHeader2
http://hxraid.iteye.com/blog/647759（桶排序效率分析）
https://www.cs.princeton.edu/~rs/AlgsDS07/18RadixSort.pdf(princeton radix sort)

---

http://segmentfault.com/a/1190000002595152 ?? ?? ?? ??

總結(jié)

以上是生活随笔為你收集整理的count sort, radix sort, bucket sort的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。