线性排序之基数排序，桶排序，计数排序

基数排序，桶排序，计数排序是三种线性排序方法，突破了比较排序的O(nlogn)的限制。但是只适用于特定的情况。

基数排序

以下为维基百科的描述：

基数排序 :
将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。

基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant
digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。

基数排序的效率：
基数排序的时间复杂度是O(k·n)，其中n是排序元素个数，k是数字位数。注意这不是说这个时间复杂度一定优于O(n·log(n))，k的大小取决于数字位的选择（比如比特位数），和待排序数据所属数据类型的全集的大小；k决定了进行多少轮处理，而n是每轮处理的操作数目。

以排序n个不同整数来举例，假定这些整数以B为底，这样每位数都有B个不同的数字，k =
logB(N)，N是待排序数据类型全集的势。虽然有B个不同的数字，需要B个不同的桶，但在每一轮处理中，判断每个待排序数据项只需要一次计算确定对应数位的值，因此在每一轮处理的时候都需要平均n次操作来把整数放到合适的桶中去，所以就有：

k约等于logB(N) 所以，基数排序的平均时间T就是：

T～= logB(N)·n 其中前一项是一个与输入数据无关的常数，当然该项不一定小于logn

如果考虑和比较排序进行对照，基数排序的形式复杂度虽然不一定更小，但由于不进行比较，因此其基本操作的代价较小，而且在适当选择的B之下，k一般不大于logn，所以基数排序一般要快过基于比较的排序，比如快速排序。

简单来说，基数排序就是从最低位排序一直到最高位排序完成。时间复杂度O(kn) 空间复杂度O(n)

#include <iostream>
using namespace std;
int maxbit(int data[], int n)
{
    int d = 1;
    int max = data[0];
    for (int i = 1; i < n; i++) {  // 找出最大值
        if (data[i] > max)
            max = data[i];
    }
    int radix = 10;
    while (max >= radix) {
        d++;
        radix *= 10;
    }
    return d;
}
void radixsort(int data[], int n) {
    int d = maxbit(data, n); // 求data中最大数具有的位数，决定循环几次
    int *count = new int[10]; // 10 个桶
    int *tmp = new int[n];
    int radix = 1;
    for (int i = 0; i < d; i++) {
        // 每次清零桶计数器
        for (int j = 0; j < 10; j++) 
            count[j] = 0;
        // 统计每个桶中的记录数
        for (int j = 0; j < n; j++) {  
            int k = (data[j] / radix) % 10;
            count[k]++;
        }
        // 分配tmp的位置
        for (int j = 1; j < 10; j++) {
            count[j] = count[j - 1] + count[j]; // count[j] 中 是 j 桶 和比 j 小的桶中的记录数的和
        }
        // 倒着来，将所有桶中记录依次收集到tmp中
        for (int j = n - 1; j >= 0; j--) {
            int k = (data[j] / radix) % 10;
            tmp[count[k] - 1] = data[j];
            count[k]--;
        }
        // 将临时数组复制回data
        for (int j = 0; j < n; j++)
            data[j] = tmp[j];
        radix *= 10;
    }
    delete []count;
    delete []tmp;
    count = NULL;
    tmp = NULL;
}
int main()
{
    int data[] = { 52,353,458,279,129,152 };
    radixsort(data, 6);
    for (int i = 0; i < 6; i++)
        cout << data[i] << " ";
}

计数排序：

维基百科-计数排序
计数排序对于数据范围很大的数组，需要大量时间和内存。适合排序小范围内的整数。
算法的步骤如下：

• 找出待排序的数组中最大和最小的元素
• 统计数组中每个值为i的元素出现的次数，存入数组C的第i项
• 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
• 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

void count_sort(int data[], int n) { 
    int *tmp = new int[n];
    int max = data[0]; // max为data中的最大数
    int min = data[0];
    for (int i = 0; i < n; i++) {
        if (data[i] > max)
            max = data[i];
        if (data[i] < min)
            min = data[i];
    }
    int len = max - min + 1;
    int *count = new int[len];
    for (int i = 0; i < len; i++)
        count[i] = 0;
    for (int i = 0; i < n; i++)
        count[data[i]-min]++;
    for (int j = 1; j < len; j++)
        count[j] += count[j - 1];
    for (int i = n - 1; i >= 0; i--) {
        tmp[count[data[i]-min] - 1] = data[i];
        count[data[i]-min]--;
    }
    for (int i = 0; i < n; i++)
        data[i] = tmp[i];
    delete []count;
    delete []tmp;
}

桶排序

桶排序有其局限性，适合元素值集合并不大的情况。
假设排序数的范围是[0,1]，在[0,1]内平均划分为k个桶，将待排序数放在这些桶里。对于桶内元素个数大于 1 的进行桶内排序（常用插入排序）。因为平均划分，所以一个桶内的元素不会太多，时间复杂度O(n)，点击打开维基百科-桶排序

基本思想：
假设有一组长度为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)。依次将所有关键字全部堆入桶中，并在每个非空的桶中进行快速排序后得到如下图所示：

内容来自：【排序结构6】 桶排序：http://hxraid.iteye.com/blog/647759

class Node {
public:
    int key;
    Node* next;
    Node(int key = 0) {
        this->key = key;
        next = NULL;
    }
};
void bucketSort(int data[], int n, int bucket_size) {
    Node** bucket = new Node*[bucket_size];
    for (int i = 0; i < bucket_size; i++) 
        bucket[i] = new Node(0); //初始化每个桶的头节点，头节点的key表示桶里元素的个数，后面的节点key表示元素值
    for (int j = 0; j < n; j++) {
        Node* node = new Node(data[j]);
        int k = data[j] / 10;  // 设定映射函数
        if (bucket[k]->key == 0) {
            bucket[k]->next = node;
        } else {
            Node* p = bucket[k];
            while (p->next && node->key > p->next->key) { // 插入排序
                p = p->next;
            }
            Node* tmp = p->next;
            p->next = node;
            node->next =tmp;
        }
        bucket[k]->key++;
    }
    for (int i = 0, j = 0; i < bucket_size; i++) {
        if (bucket[i]->key == 0)
            continue;
        Node* p = bucket[i]->next;
        while (p != NULL) {
            data[j++] = p->key;
            p = p->next;
        }
    }
}

int main()
{
    int data[] = { 52,45,2,14,58,33 };
    bucketSort(data, 6, 10);
    for (int i = 0; i < 6; i++)
        cout << data[i] << " ";
    cout << endl;
}

基于桶排序的一个应用：对班级学生的成绩排序，按分数从高到低，打印学号

#include <iostream>
using namespace std;
class Student {
public:
    int id;
    int score;
    Student(int id, int score) {
        this->id = id;
        this->score = score;
    }
    void display() {cout << "id: " << id << "\t" << "score: " << score << endl;}
};
class Node {
public:
    Student* std;
    Node* next;
    Node(Student* std = NULL) {
        this->std = std;
        next = NULL;
    }
};
void bucketSort(Student** (&student) , int n, int bucket_size) {
    Node** bucket = new Node*[bucket_size];
    for (int i = 0; i < bucket_size; i++) 
        bucket[i] = new Node(NULL); //初始化每个桶的头节点，头节点的key表示桶里元素的个数，后面的节点key表示元素值
    for (int j = 0; j < n; j++) {
        Node* node = new Node(student[j]);
        int k = student[j]->score / 10;  // 设定映射函数
        if (bucket[k]->std == NULL) {
            bucket[k] = node;
        } else {
            Node* p = bucket[k];
            while (p->next && node->std->score <= p->next->std->score) { // 插入排序
                p = p->next;
            }
            Node* tmp = p->next;
            p->next = node;
            node->next =tmp;
        }
    }
    for (int i =bucket_size-1 , j = 0; i >= 0; i--) {
        if (bucket[i]->std == NULL)
            continue;
        Node* p = bucket[i];
        while (p != NULL) {
            student[j++] = p->std;
            p = p->next;
        }
    }
    // delete bucket
}


int main()
{
    int score[] = {99,99,100,88,76,88,99,60,55,100,77};
    int size = sizeof(score)/sizeof(score[0]);
    Student** student = new Student* [size];
    for (int i = 0; i < size; i++) {
        student[i] = new Student(i+1, score[i]);
    }
    // 从高到低学生分数排序
    bucketSort(student, size, 11);  // 0~100 设定为11个桶
    for (int i = 0; i < size; i++) {
        student[i]->display();
    }
    // delete student
}