【基数排序】

1. 冒泡排序
2. 选择排序
3. 快速排序
4. 插入排序
5. 希尔排序
6. 归并排序
7. 堆排序
8. 计数排序
9. 桶排序

1. 算法思想

一种多关键字的排序算法，可用桶排序实现。

2. 算法步骤

1. 取得数组中的最大数，并取得位数；
2. arr为原始数组，从最低位开始取每个位组成radix数组；
3. 对radix进行计数排序（利用计数排序适用于小范围数的特点）。

3. 代码实现（C++）

#include <iostream>
using namespace std;

int maxbit(int data[], int n) //辅助函数，求数据的最大位数
{
    int maxData = data[0]; //先求出最大数
    for (int i = 1; i < n; ++i)
    {
        if (maxData < data[i])
        {
            maxData = data[i];
        }
    }
    int d = 0;
    while (maxData > 0)
    {
        maxData /= 10;
        ++d;
    }
    return d;
}

void radixSort(int data[], int n)
{
    int d = maxbit(data, n);
    int* tmp = new int[n];
    int* count = new int[10]; //计数器
    int i, j, k;
    int radix = 1;
    for (i = 1; i <= d; i++) //进行d次排序
    {
        for (j = 0; j < 10; j++)
        {
            count[j] = 0; //每次分配前清空计数器
        }
        for (j = 0; j < n; j++)
        {
            k = (data[j] / radix) % 10; //统计每个桶中的记录数
            count[k]++;
        }
        for (j = 1; j < 10; j++)
        {
            count[j] = count[j - 1] + count[j]; //将tmp中的位置依次分配给每个桶
        }
        for (j = n - 1; j >= 0; j--) //将所有桶中记录依次收集到tmp中
        {
            k = (data[j] / radix) % 10;
            tmp[count[k] - 1] = data[j];
            count[k]--;
        }
        for (j = 0; j < n; j++) //将临时数组的内容复制到data中
        {
            data[j] = tmp[j];
        }
        radix = radix * 10;
    }
    delete[]tmp;
    delete[]count;
}

int main()
{
    int arr[] = { 3,7,21,756,32,2,8,43,26,32,13,99 };
    int len = sizeof(arr) / sizeof(int);
    radixSort(arr, len);

    for (int i = 0; i < len; ++i)
    {
        cout << arr[i] << " ";
    }
    cout << endl;

    system("pause"); //按任意键继续
    return 0;
}

4. 补充知识

• 稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 仍然在 b 的前面，则为稳定排序；
• 非稳定排序：如果 a 原本在 b 的前面，且 a == b，排序之后 a 可能不在 b 的前面，则为非稳定排序。
• 原地排序：原地排序就是指在排序过程中不申请多余的存储空间，只利用原来存储待排数据的存储空间进行比较和交换的数据排序；
• 非原地排序：需要利用额外的数组来辅助排序。
• 时间复杂度：一个算法执行所消耗的时间（次数，因为同一程序在不同系统的执行时间可能不同）；
• 空间复杂度：运行完一个算法所需的内存大小。