【初赛】基数排序

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog?m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。——百度百科

浅显易懂的来讲，基数排序就是将整数按位数切割成不同的数字，然后按每个位数分别比较。

附动图一张：

4. 复杂度分析

时间复杂度：$O(k?N)$
空间复杂度：$O(k+N)$
稳定性：稳定
设待排序的数组$R[\mathrm{1..}n]$，数组中最大的数是d位数，基数为r（如基数为10，即10进制，最大有10种可能，即最多需要10个桶来映射数组元素）。

处理一位数，需要将数组元素映射到r个桶中，映射完成后还需要收集，相当于遍历数组一遍，最多元素数为n，则时间复杂度为$O(n+r)$。所以，总的时间复杂度为$O(d?(n+r))$。

基数排序过程中，用到一个计数器数组，长度为r，还用到一个rn的二位数组来做为桶，所以空间复杂度为$O(rn)$。

基数排序基于分别排序，分别收集，所以是稳定的。
但其稳定性需基于一个条件：桶的实现为队列，若为栈，它的稳定性将不保证。

Code：

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 = 1;
    int p = 10;
    while (maxData >= p)
    {
        //p *= 10; // Maybe overflow
        maxData /= 10;
        ++d;
    }
    return d;
/*    int d = 1; //保存最大的位数
    int p = 10;
    for(int i = 0; i < n; ++i)
    {
        while(data[i] >= p)
        {
            p *= 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 radix = 1;
    for(int i = 1; i <= d; i++){ //进行d次排序
    
        for(int j = 0; j < 10; j++)
            count[j] = 0; //每次分配前清空计数器
        for(int j = 0; j < n; j++){
        
            k = (data[j] / radix) % 10; //统计每个桶中的记录数
            count[k]++;
        }
        for(int j = 1; j < 10; j++)
            count[j] = count[j - 1] + count[j]; //将tmp中的位置依次分配给每个桶
        for(int j = n - 1; j >= 0; j--){
            k = (data[j] / radix) % 10;
            tmp[count[k] - 1] = data[j];
            count[k]--;
        }
        for(int j = 0; j < n; j++)
            data[j] = tmp[j];
        radix = radix * 10;
    }
    return ;
}

各位观众姥爷，求点赞关注收藏！！！