线性排序：如何根据年龄给100万用户的数据排序？

学习《数据结构与算法之美》，极客时间专栏笔记

................................................................................

桶排序、计数排序、基数排序是三种时间复杂度是O(n)的排序算法，因为这些排序的时间复杂度是线性的，所以我们把这类排序算法叫作线性排序（Linear sort）。这三个算法不涉及元素之间的比较操作，是非基于比较的排序算法

问题：如何根据年龄给100万用户排序？

 

桶排序（Bucket sort）

核心思想：

将要排序的数据分到几个有序的桶里，每个桶里的数据再单独进行排序。桶内排序之后，再把每个桶里的数据依次取出，组成的序列就是有序的了。

示图：

 

 

 桶排序的时间复杂度为什么是O(n) 呢？

如果要排序的数据有n 个，我们将其均分到 m 个桶内，每个桶里就有 k = n/m 个元素。每个桶内部使用快速排序，时间复杂度为O(klogk)。m个桶排序的时间复杂度就是 O(mklogk)，把 k = n/m 代入可得时间复杂度为O(nlog(n/m))。当桶的个数m接近数据个数n时，log(n/m)就是一个非常小的常量。这时候桶排序的时间复杂度就接近于O(n)桶排序

看起来很优秀，那它是不是可以替代我们之前讲的排序算法呢？

当然是不可以的。桶排序对要排序的数据的要求是非常苛刻的。

1. 首先，要排序的数据需要很容易能划分到 m 个桶，并且，桶与桶之间有着天然的大小顺序。这样每个桶内的数据排序完之后，桶与桶之间就不需要再进行排序了。
2. 其次，数据在各个桶之间分布是比较均匀的。如果数据经过桶的划分之后，有些桶的数据非常多，有些非常少，很不均匀，那桶内排序的时间复杂度就不是常量级了。极端情况一，如果数据都被划分到一个桶里，那就退化成O(nlogn)的排序算法了。

**桶排序比较适合用在外部排序中。**所谓的外部排序就是数据存储在外部磁盘中，数据量比较大，内存有限，无法将数据全部加载到内存中。

例子：

比如我们有10G 的订单数据，我们希望根据订单金额（假设金额过都是正整数）进行排序，但我们的内存有限，只有几百MB，没办法一次性把10GB 的数据加载到内存中，这个时候怎么办呢？

1. 我们可以先扫描一遍文件，确定订单金额的数据范围。假定订单最小值是1元，最大值是10万元。把订单划分到100个桶里，第一个桶里订单金额的范围是1——1000，第二个桶的范围是1001——2000，依次类推。一个桶对应一个文件，文件编号从 00——99
2. 理想情况下，10GB的订单数据比较平均的分到100个文件中，每个文字里有约100MB的订单数据。然后把这100个文件依次放入内存中，用快排来排序。当所有文件里的订单数据排好序之后。再按照文件编号，从小到大把这100个的数据写入到一个文件中，可得到这10G订单排序好的数据了。
3. 但数据不大可能均匀分布，若某个桶内的数据特别多，比如订单金额5001——6000的特别多，可以将这个区间的订单数据再细分到十个桶内（5001——5100，5101——5200……），其它的操作同上，就可以解决问题了。总之某个桶里的数据，内存放下下，就再细分

代码实现：

　　逻辑思路：

• 设置一个定量的数组当作空桶子。
• 寻访序列，并且把项目一个一个放到对应的桶子去。
• 对每个不是空的桶子进行排序。
• 从不是空的桶子里把项目再放回原来的序列中

 1 #include
 2 #include
 3 #include
 4 using namespace std;
 5 const int BUCKET_NUM = 10;
 6 struct ListNode{
 7     explicit ListNode(int i=0):mData(i),mNext(NULL){}
 8     ListNode* mNext;
 9     int mData;
10 };
11 ListNode* insert(ListNode* head,int val){
12     ListNode dummyNode;
13     ListNode *newNode = new ListNode(val);
14     ListNode *pre,*curr;
15     dummyNode.mNext = head;
16     pre = &dummyNode;
17     curr = head;
18     while(NULL!=curr && curr->mData<=val){
19         pre = curr;
20         curr = curr->mNext;
21     }
22     newNode->mNext = curr;
23     pre->mNext = newNode;
24     return dummyNode.mNext;
25 }
26 ListNode* Merge(ListNode *head1,ListNode *head2){
27     ListNode dummyNode;
28     ListNode *dummy = &dummyNode;
29     while(NULL!=head1 && NULL!=head2){
30         if(head1->mData <= head2->mData){
31             dummy->mNext = head1;
32             head1 = head1->mNext;
33         }else{
34             dummy->mNext = head2;
35             head2 = head2->mNext;
36         }
37         dummy = dummy->mNext;
38     }
39     if(NULL!=head1) dummy->mNext = head1;
40     if(NULL!=head2) dummy->mNext = head2;
41 
42     return dummyNode.mNext;
43 }
44 void BucketSort(int n,int arr[]){
45     vector buckets(BUCKET_NUM,(ListNode*)(0));
46     for(int i=0;ii){
47         int index = arr[i]/BUCKET_NUM;
48         ListNode *head = buckets.at(index);
49         buckets.at(index) = insert(head,arr[i]);
50     }
51     ListNode *head = buckets.at(0);
52     for(int i=1;ii){
53         head = Merge(head,buckets.at(i));
54     }
55     for(int i=0;ii){
56         arr[i] = head->mData;
57         head = head->mNext;
58     }
59 }

 

计数排序（Counting sort）

概述：

当要排序的 n 个数据，所处的范围并不大时，比如最大值是k，就可以把数据分成 k 个桶。每个桶内的数据是相同的，省去了桶内排序的时间。
就拿高考查分系统来说 ？当你查分数时，系统会显示出分数，及在省排名。假设该省50万考生，如何通过成绩快速排序得出名次？

考生满分是900分，最小是0分，这个数据的范围很小，所以可以分成901个桶，对应分数0到900分。根据考生的成绩，我们将50万考生划分到这901个桶里。桶内分数是一样的，不需要排序。依次遍历桶内的数据，放到一个数组中，就实现了50考生的排序。只涉及遍历操作，时间复杂度为O(n)。

计数排序算法的思想就这么简，和桶排序的方法类似，只是桶的粒度大小不一样。但它为什么叫计数排序呢？计数又体现在哪里？
为了方便说明，对数据规模做了简化。假设只有8个考生，分数在0到5分之间。假设这8个考生的分数在0到5之间。把这8个考生的成绩放入一个数组A[8]中，它们分别是：2，5，3，0，2，3，0，3.

考生的成绩从0到5分，我们使用大小为6的数组C[6]表示桶，其中下标对应分数。不过，C[6]内存储的并不是考生，而是对应的考生个数。像我们刚刚举的那个例子，我们只需要遍历一遍考生的分数，就可以得到C[6]的值

如图中所示，分数为3分考生有3个，小于3分的考生有4个，所以，成绩为3分的考生在排序之后的数组R[8]，会保存下标4，5，6的位置

那我们如何快速计算出，每个分数的考生在有序数组中对应的存储位置呢？这个处理方非常巧妙，不容易想到。

思路是这样的：我们对C[6]数组顺序求和，C[6]存储的数据就变成了正面的样子。C[k]里存储小于等于分数k 的考生个数

然后就进入比较难理解的部分。我们从后到前依次扫描数组A。比如，当扫描到 3 时，我们从数组C中取出下标为3的值7，也就是说，到目前为止，包括自己在内，分数小于等于3的考生有7个，也就是说3是数组R中的第7个元素。当3放入数组R后，小于等于3的元素只剩下6个了，所以相应的C[3]要减1，变成6。依次类推，当我们扫描到第2个分数为3的考生时，就会把它放入数组R中的第6个元素的位置。在这里插入图片描述

 

代码实现:

 1 // 计数排序，a是数组，n是数组大小。假设数组中存储的都是非负整数。
 2 public void countingSort(int[] a, int n) {
 3   if (n <= 1) return;
 4 
 5   // 查找数组中数据的范围
 6   int max = a[0];
 7   for (int i = 1; i < n; ++i) {
 8     if (max < a[i]) {
 9       max = a[i];
10     }
11   }
12 
13   int[] c = new int[max + 1]; // 申请一个计数数组c，下标大小[0,max]
14   for (int i = 0; i <= max; ++i) {
15     c[i] = 0;
16   }
17 
18   // 计算每个元素的个数，放入c中
19   for (int i = 0; i < n; ++i) {
20     c[a[i]]++;
21   }
22 
23   // 依次累加
24   for (int i = 1; i <= max; ++i) {
25     c[i] = c[i-1] + c[i];
26   }
27 
28   // 临时数组r，存储排序之后的结果
29   int[] r = new int[n];
30   // 计算排序的关键步骤，有点难理解
31   for (int i = n - 1; i >= 0; --i) {
32     int index = c[a[i]]-1;
33     r[index] = a[i];
34     c[a[i]]--;
35   }
36 
37   // 将结果拷贝给a数组
38   for (int i = 0; i < n; ++i) {
39     a[i] = r[i];
40   }
41 }

总结：

计数排序只能用在数据范围不大的场景中，如果数据范围 k 比要排序的数据 n 大很多，就不适合用计数排序了。而且，计数排序只能给非负整数排序，如果要排序的数据是其他类型的，要将其在不改变相对大小的情况下，转化为非负整数

 

基数排序（Radix sort）

我们再来看这样一个排序问题。假设我们有10万个手机号码，希望将这10万个手机号码从小到大排序，你有什么比较快速的排序方法呢？
用之前说到的快排，时间复杂度可以做到O(nlogn)，还有更高效的排序算法吗?
这个问题里有这样的规律：假设经比较两个电话号码a ，b 的大小，如果在前面几个位中，a手机号码已经比b 手机号码大了，那后面的几位就不用比较了。
借助稳定排序算法，这里有一个巧妙的实现思路。先按照最后一位来排序手机号码，然后，再按倒数第二们重新排序，以此类推，经过11次排序后，手机号码就都有序了。
简化数据，用这几个字母的例子来看图

 

 根据每位排序，可以用刚讲过的桶排序或者计数排序，时间复杂度可以做到O(n)。如果要排序的数据有k 位，就需要 k 次排序，总的时间复杂度就是O(kn)。当 k 不大的时候，比如手机号码的例子，是11位，O(kn)就近似等于O(n)。

代码实现：

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

• 分配，先从个位开始，根据位值(0-9)分别放到0~9号桶中（比如53,个位为3，则放入3号桶中）
• 收集，再将放置在0~9号桶中的数据按顺序放到数组中
• 重复(1)(2)过程，从个位到最高位，直到排好序为止（比如32位无符号整形最大数4294967296，最高位10位）

 1 int GetNumInPos(int num,int pos)// 找到num的从低到高的第pos位的数据
 2 {
 3     int temp = 1;
 4     for (int i = 0; i < pos - 1; i++)
 5         temp *= 10;
 6     
 7     return (num / temp) % 10;
 8 }
 9  
10  
11 //基数排序  pDataArray 无序数组；iDataNum为无序数据个数
12 void RadixSort(int* pDataArray, int iDataNum)
13 {
14     int *radixArrays[RADIX_10];    //分别为0~9的序列空间
15     for (int i = 0; i < 10; i++)
16     {
17         radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));
18         radixArrays[i][0] = 0;    //index为0处记录这组数据的个数
19     }
20     
21     for (int pos = 1; pos <= KEYNUM_31; pos++)    //从个位开始到31位
22     {
23         for (int i = 0; i < iDataNum; i++)    //分配过程
24         {
25             int num = GetNumInPos(pDataArray[i], pos);
26             int index = ++radixArrays[num][0];
27             radixArrays[num][index] = pDataArray[i];
28         }
29         
30         for (int i = 0, j =0; i < RADIX_10; i++)    //收集
31         {
32             for (int k = 1; k <= radixArrays[i][0]; k++)
33                 pDataArray[j++] = radixArrays[i][k];
34             radixArrays[i][0] = 0;    //复位
35         }
36     }
37 }

 

总结

它对要求排序的的数据是有要求的，需要可以分割出独立的“位”来比较，而且位之间有递进关系，如果 a 数据的高位比 b 数据大，那剩下的低位就不用比较了。除此之外，每一位的数据范围不能太大，要可以用线性排序算法来排序，否则，基数排序的时间复杂度就无法做到o(n)了