c++十大排序算法之基数排序

​
​

活动地址：CSDN21天学习挑战赛

正文

• At first，我们先look一张我从某文章*的表格，来了解一下这几大算法
  
• 图都看了，那我也不得不提一嘴，图里面的东西了

  • 算法效率
    在一个算法设计完成后，还需要对算法的执行情况做一个评估。一个好的算法，可以大幅度的节省运行的资源消耗和时间。在进行评估时不需要太具体，毕竟数据量是不确定的，通常是以数据量为基准来确定一个量级，通常会使用到时间复杂度和空间复杂度这两个概念。

  • 时间复杂度
    通常把算法中的基本操作重复执行的频度称为算法的时间复杂度。算法中的基本操作一般是指算法中最深层循环内的语句（赋值、判断、四则运算等基础操作)。我们可以把时问频度记为T(n)，它与算法中语句的执行次数成正比。其中的n被称为问题的规模，大多数情况下为输入的数据量。

    对于每一段代码，都可以转化为常数或与n相关的函数表达式，记做f(n)。如果我们把每一段代码的花费的时间加起来就能够得到一个刻画时间复杂度的表达式，在合并后保留量级最大的部分即可确定时间复杂度，记做O(f(n))，其中的O就是代表数量级。
    常见的时间复杂度有（由低到高): O(1)、O(log2 n)、O(n)、O(n log2n)、O(n2)、o(n3)、O(2")、O(nl)。

  • 空间复杂度

  • 程序从开始执行到结束所需要的内存容量，也就是整个过程中最大需要占用多少的空间。为了评估算法本身，输入数据所占用的空间不会考虑，通常更关注算法运行时需要额外定义多少临时变量或多少存储结构。如:如果需要借助一个临时变量来进行两个元素的交换，则空间复杂度为O(1).

时间复杂度与空间复杂度的分类

时间复杂度

• 最坏的情况
  最坏的情况莫过于，完整的遍历了整个集合，也没有找到需要找的的元素，循环执行次数与n相关，所以时间复杂度为O(n).

• 最好的情况
  第一次循环便找到了元素，则时间复杂度为常数级O(1);

• 平常的情况
  综合两种情况，顺序查找的时间复杂度为O(n)，属于查找较慢的算法。

空间复杂度

算法不会改变原有的元素集合，只需要一个额外的变量控制索引变化，所以空间复杂度为常数级:O(1)。

基数排序

• 基数排序（Radix sort）是一种非比较型整数排序算法，其原理是将数据按位数切割成不同的数字，然后按每个位数分别比较。它是一种非比较型的排序算法，最早用于解决卡片排序的问题。

• 它的工作原理是将待排序的元素拆分为k个关键字，其中k为最大值的位数，从低位开始进行稳定排序。（注意：数列中的元素都是非负整数）

• 基数排序是一种稳定的排序算法

• 假设说，我们要对 100 万个手机号码进行排序，应该选择什么排序算法呢？排的快的有归并、快排时间复杂度是 O(nlogn)，计数排序和桶排序虽然更快一些，但是手机号码位数是11位，那得需要多少桶？内存条表示不服。
  这个时候，我们使用基数排序是最好的选择。

c++实现基数排序

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

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 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;
}

JAVA实现

import java.util.ArrayList;
import java.util.Arrays;
//基数排序
public class RadixSort {
    public static void main(String[] args) {
        int[] array = new int[]{20, 21, 8, 30, 20, 6, 51, 14};
        RadixSort(array);
        System.out.println(Arrays.toString(array));
    }
    public static int[] RadixSort(int[] arr){
        if(arr.length == 0 || arr.length ==1)
            return arr;
        // max 指数组中最大的数，maxDigit 指这个最大的数是几位数
        int max = arr[0];
        for(int x:arr)
            max = Math.max(x,max);
        int maxDigit = 0;
        while(max != 0){
            max /= 10;
            maxDigit++;
        }
        // mod 用于为数组中的数取余数，div 用于把通过 mod 取的余数变成个位数
        int mod = 10;
        int div = 1;
        ArrayList<ArrayList<Integer>> bucket = new ArrayList<ArrayList<Integer>>();
        for(int j = 0;j < 10;j++){
            bucket.add(new ArrayList<Integer>());
        }
        for(int i = 0;i<maxDigit;i++,mod *= 10,div *= 10){
            // 打印这一轮的排序结果
            System.out.println(Arrays.toString(arr));
            for(int j = 0;j < arr.length;j++){
                // num 指当前元素 arr[j] 的个/十/百/千位是几
                int num = (arr[j] % mod) / div;
                bucket.get(num).add(arr[j]);
            }
            int index = 0;
            for(int j = 0;j < 10;j++){
                if(bucket.get(j).size() != 0){
                    for(int x:bucket.get(j))
                        arr[index++] = x;
                    // 将桶中所有的动态数组清空，否则第二次循环开始再用到这些动态数组时里面还会有数据
                    bucket.get(j).clear();
                }
            }
        }
        return arr;
    }
}

python实现

def radix_sort(s):
   """基数排序"""
   i = 0 # 记录当前正在排拿一位，最低位为1
   max_num = max(s)  # 最大值
   j = len(str(max_num))  # 记录最大值的位数
   while i < j:
       bucket_list =[[] for _ in range(10)] #初始化桶数组
       for x in s:
           bucket_list[int(x / (10**i)) % 10].append(x) # 找到位置放入桶数组
       print(bucket_list)
       s.clear()
       for x in bucket_list:   # 放回原序列
           for y in x:
               s.append(y)
       i += 1

if __name__ == '__main__':
   a = [334,5,67,345,7,345345,99,4,23,78,45,1,3453,23424]
   radix_sort(a)
   print(a)
  

参考:https://www.cnblogs.com/sfencs-hcy/p/10616446.html