基数排序算法（典型的空间换时间）

基本介绍

基数排序属于“分配式排序”，又称“桶子法”，顾名思义，它是通过键值的各个位的值将要排序的元素分配至某些桶中，达到排序的作用；

基数排序法是属于稳定性的排序，基数排序法是效率高的稳定性排序法；

基数排序是桶排序的扩展；

它是将整数按位数切割成不同的数字，然后按每个位数分别比较；

基本思想

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

图解及流程分析

将数组[53,3,542,748,14,214]使用基数排序，进行升序排序

1.先初始化一个桶（二维数组），这个二维数组对应的就是0-10这几个数字；

2.遍历原始数组，将个位数对应二维数组下标的数据，放到该二维数组中去，例如第一个数据53就放到二维数组下标为3的位置中去，以此类推；

3.放完之后，再将这些数据按顺序从二维数组中取出来=》得到第一轮排序的结果arr={542,53,3,14,214,748}

 4.再遍历取出来的这个数组，根据十位数放到二维数组的对应下标处，例如我们第一个元素542就放到二维数组下标为4的位置中去；

 5.再依次取出这些元素，得到第二轮排序的结果arr={3,14,214,542,748,53}，然后根据百位数进行最后一轮排序：

 最终取出这些元素arr={3,14,53,214,542,748}，即是最终结果；排序的次数等于数组中的最高位数；

代码实现

/**
 * @Author:Strine
 * 基数排序算法
 * */
public static void getRadixSort(int arr[]){
    //初始化二维数组
    //为了防止数组越界，因此我们需要把数组的长度设置的大一点，因此基数排序也是一个典型的空间换时间的算法
    int bucket[][]=new int[10][arr.length];
    //用来记录二维数组的第几个桶中有多少个元素
    int bucketCounts[]=new int[10];
    //算出最大值
    int max=0;
    for (int i = 0; i < arr.length; i++) {
       if (max<arr[i]){
           max=arr[i];
       }
    }
    //基于最大值进而算出最高位数，用来判断需要进行多少轮循环
    int maxSize=(max+"").length();
    int bucketGap=1;  //每次取余的除数
    int temp=0;  //临时索引

    for (int k = 0; k < maxSize; k++) {
        //放数据
        for (int i = 0; i < arr.length; i++) {
            temp=arr[i]/bucketGap%10;
            bucket[temp][bucketCounts[temp]]=arr[i];
            bucketCounts[temp]++;
        }
        //取出元素
        int arrIndex=0;
        for (int i = 0; i < bucketCounts.length; i++) {
            if (bucketCounts[i]!=0){
                for (int j = 0; j < bucketCounts[i]; j++) {
                    arr[arrIndex]=bucket[i][j];
                    arrIndex++;
                    //取出元素之后让其归0
                    bucket[i][j]=0;;
                }
                //再让记录的位置归0
                bucketCounts[i]=0;
            }
        }
        //进行下一轮循环
        bucketGap=bucketGap*10;
    }
}

代码简述

1.初始化一个二维数组，该二维数组的行数是固定的10（根据0-10这几个数字进行存放），而二维数组的列数我们其实是不知道的，因此这里如果想要提高空间利用率的话可以设置一个默认容量，然后再写一个扩容方法，但是这样比较麻烦，我们就直接做最坏的打算，也就是让他的列数直接等于原数组的长度，因此从这里就可以看出基数排序是典型的用空间换时间的算法；

2.初始化一个一位数组，用来记录二维数组对应位置存放的元素个数（方便我们后续取元素）；

3.找出原数组中最大的元素的位数（用来判断我们需要循环多少次）；

4.因为我们是从个位开始取，因此每一次往高位递增都是以10的倍数递增再对10取余，因此需要定义一个变量bucketGap来让每次循环过后以10的倍数递增（个位/十位/百位/千位......）；

5.我们循环的次数就是原数组的最高位数；

6.遍历原数组，依次取出每个元素的个位数，然后放在二维数组的对应下标位置，行数就是该个位数，列数就是在一位数组中记录的元素个数；（例如234的个位数是4，因此放在二维数组的第四行，在一维数组中记录了对应位置的元素个数，因此列数就是一维数组对应下标的值），然后添加成功之后让一维数组对应位置的值自增；

7.遍历一维数组，如果对应下标不为0则说明是有值的，因此遍历该值，一维数组的下标加不断递增的值就是对应二维数组的元素，然后取出这些元素放入原数组中，并且在取出之后需要将其归0，还要把一位数组对应下标位置归0；

8.最终让bucketGap乘以10进入下一次循环

效果展示

 性能测试

基数排序使用了极大的空间损耗去换取时间，我们依旧使用5000000条随机数的数组去测试统计耗时，发现它快到离谱：

存在的问题

通过我们的代码实现和测试可以发现，基数排序是使用了大量的空间去换取时间，因此如果当我们数据特别大的时候，那么它的空间损耗也特别特别大（需要维护一个二维数组和一维数组），我们再加大测试量可以发现，它报了一个致命的错误：内存不足：

结论

1.基数排序是对传统桶排序的扩展，速度很快；

2.基数排序是典型的空间换时间的方式，占用内存很大，因此当面对海量数据排序的时候很容易造成OutOfMemoryError

3.基数排序是稳定的【注释：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中r[i]=r[j]且r[i]在r[j]前面，而在排序后的序列中r[i]仍在r[j]前面】则称这种排序算法是稳定的，否则称为不稳定的；

4.如果在原数组中有负数，就尽量不要使用基数排序，因为会造成数组越界的问题（如果一定要使用的话就在存值的时候求它的绝对值，而取值的时候做一个反转）；