计数排序 (Counting Sort)

---

讲解来源：[https://byvoid.com/zhs/blog/sort-radix/](https://byvoid.com/zhs/blog/sort-radix/)

---

note:

非基于比较的排序，如计数排序，桶排序，和在此基础上的基数排序，可以突破O(NlogN)时间下限。但要注意的是，非基于比较的排序算法的使用都是有条件限制的，例如元素的大小限制，相反，基于比较的排序则没有这种限制(在一定范围内)。但并非因为有条件限制就会使非基于比较的排序算法变得无用，对于特定场合有着特殊的性质数据，非基于比较的排序算法则能够非常巧妙地解决。

description

1. 假设我们有一个待排序的整数序列A，其中元素的最小值不小于low，最大值不超过high。建立一个长度为K的线性表C，用来记录不大于每个值的元素的个数。
2. 举一个极端的栗子：数组里面只有两种数，只要至少每种数的个数，是不是马上就知道他们应该怎么排序了
3. 算法思路如下：

1). 扫描序列A，以A中的每个元素的值为索引，把出现的个数填入C中。此时C[i]可以表示A中值为i的元素的个数。
2). 对于C从头开始累加，使C[i]<-C[i]+C[i-1]。这样，C[i]就表示A中值不大于i的元素的个数。
3). 按照统计出的值，输出结果。

4. 代码：

/******************************************
 * @Author       : 鱼香肉丝没有鱼
 * @Date         : 2021-09-20 12:55:54
 * @LastEditors  : 鱼香肉丝没有鱼
 * @LastEditTime : 2021-11-24 01:29:41
 ******************************************/

// 计数排序
#include <iostream>
using namespace std;

int low = 1;  //元素下限
int high = 10;  //元素上限

void CountingSort(int* arr, int* order, int n)
{
    int* fre = NULL;  //频率数组frequency，fre[i]就是数字i的出现次数

    int i;
    int frelen = high - low + 1;  //频率数组的长度
    fre = new int[frelen];

    memset(fre, 0, sizeof(int) * (frelen));  //初始化频率数组
    for(i = 0; i < n; i++)
        fre[arr[i] - low]++;  //计算得到频率数组

    for(i = 1; i < frelen; i++)
        fre[i] += fre[i - 1];  //重用分布

    for(i = n - 1; i >= 0; i--) { //应该从右至左，不然就不稳定了
        order[fre[arr[i] - low] - 1] = arr[i];  //个数从1开始，下标从0开始，所以要减1
        fre[arr[i] - low]--;
    }

    delete[] fre;
}

int main(int argc, char* argv[])
{
    int n = 15;

    int num[n] = {2, 8, 5, 1, 10, 5, 9, 9, 3, 5, 6, 6, 2, 8, 2};
    // int len  =sizeof(num)/sizeof(num[0])
    int* order = NULL;  //排好序的数组
    order = new int[n];
    CountingSort(num, order, n);
    cout << "排序后的数组为:" << endl;
    for(register int i = 0; i < n; i++)
        cout << order[i] << " ";
    cout << endl;

    delete[] order;
    return 0;
}

// 排序后的数组为：
// 1 2 2 2 3 5 5 5 6 6 8 8 9 9 10

---

补充：

教材中基于比较的计数排序：
code:

// 计数排序
#include <iostream>
using namespace std;

void CountingSort(int* arr, int* order, int n) {
    int* count = new int[n];  // count[i] ：数组中比arr[i]小或者等的元素个数
    for(int i = 0; i < n; i++) count[i] = 0;
    for(int i = 0; i < n - 1; i++)
        for(int j = i + 1; j < n; j++) {
            if(arr[i] < arr[j])
                count[j] = count[j] + 1;
            else
                count[i] = count[i] + 1;
        }
    for(int i = 0; i < n; i++) order[count[i]] = arr[i];

    delete[] count;
}

int main(int argc, char* argv[]) {
    int n = 15;
    int arr[n] = {2, 8, 5, 1, 10, 5, 9, 9, 3, 5, 6, 6, 2, 8, 2};
    // int len  =sizeof(arr)/sizeof(arr[0])
    int* order = NULL;  //排好序的数组
    order = new int[n];
    CountingSort(arr, order, n);
    cout << "排序后的数组为:" << endl;
    for(register int i = 0; i < n; i++)
        cout << order[i] << " ";
    cout << endl;

    delete[] order;
    return 0;
}

// 排序后的数组为：
// 1 2 2 2 3 5 5 5 6 6 8 8 9 9 10

---

summary

1. 计数排序的时间复杂度为O(N+K)，空间复杂度为O(N+K)。K是数据大小范围，当K不是很大时，这是一个很有效的线性排序算法
2. 是一种稳定排序算法，即排序后的相同值的元素原有的相对位置不会发生改变(表现在Order上)，这是计数排序很重要的一个性质，就是根据这个性质，我们才能把它应用到基数排序。