《基数排序》 附自动退出版源码

1、基数排序

讲解

源数据  ： 73, 22, 93, 43, 55, 14, 28, 65, 39, 81，9

第一步，统计个位数： 

0  ：                    （以0结尾的啥也没有）

1  ：81                 （以1结尾的有个81）

2  ：22                     （.....）   //自行脑补 

3  ：73 93 43

4  ：14

5  ：55 65

6  ：

7  ：

8  ：28

9  ：39 9

个位数排序后 ： 81, 22, 73, 93, 43, 14, 55, 65, 28, 39 ，9

第二步，统计十位数：

0  ：9

1  ：14

2  ：22 28

3  ：39

4  ：43

5  ：55

6  ：65

7  ：73

8  ：81

9  ：93

十位数排序后 ：9,14, 22, 28, 39, 43, 55, 65, 73, 81, 93

第二步，统计百位数：

0：9,14, 22, 28, 39, 43, 55, 65, 73, 81, 93

到此百位一个没有收工，就以百位这个不含作为排序的结果

百度百科中 给出了有最大位数的的源码：

我这里给出我改的自动退出版：

public class RadixSort {
    public static void sort(int[] number) 
    {
        int k = 0;
        int n = 1;
        int[][]temp = new int[10][number.length]; //数组的第一维表示可能的余数0-9
        int[]order = new int[10]; //数组orderp[i]用来表示该位是i的数的个数
        while(true){
            for(int i = 0; i < number.length; i++)
            {
                int lsd = ((number[i] / n) % 10);
                temp[lsd][order[lsd]] = number[i];
                order[lsd]++;
            }
            //自动退出判断
            if(order[0] == number.length){
                if( temp[0][0] <= temp[0][order[0]-1]){
                    break;
                }
            }
            for(int i = 0; i < 10; i++)
            {
                if(order[i] != 0)
                    for(int j = 0; j < order[i]; j++)
                    {
                        number[k] = temp[i][j];
                        k++;
                    }
                order[i] = 0;
            }
            n *= 10;
            k = 0;
        }
        System.out.println("循环到了"+n+"位");
    }
    public static void main(String[] args)
    {
        int[] data = {81,22,3,93,43,33,10000,14,55,65,31,1000,1000,1000};
        long startTime = System.currentTimeMillis();
        RadixSort.sort(data);
        for(int i = 0; i < data.length; i++)
        {
            System.out.print(data[i] + ",");
        }
        long endTime = System.currentTimeMillis();
        System.out.println();
        System.out.println("******用时："+ (endTime - startTime) + "ms***************** ");

    }
}

总结：

我还写过一篇  Array格式化 ， 讲的是一种按值统计数量存一位数组的数据处理方式，我起名叫做Array格式化。

我也增想过用这种Array格式化后的数组做排序，只要最后从小到大平铺一下就是一个顺序序列了。但因为临时的那个数组的长度不可控，排序时还有数据范围的限制不太好。

通过搜资料，我找到了和我想法一致但又有所改进的排序方式，就是基数排序。

区别是，我是想按照全值作为数组的下标，，而基数排序聪明的选择了一位一位排。

复杂度分析

转载：

 对于给定的n个d位数，取值范围为[0,k]，我们使用计数排序比较元素的每一位，基数排序耗时Θ(n+k)，那么基数排序的复杂度为Θ(d(n+k))。

    我们还是和快速排序进行比较，仅仅从渐进性来看，基数排序比快速排序要好，但是隐藏在Θ符号后面的常数项因子是不同的，基数排序循环次数比快速排序循环次数少，但是基数排序每次循环会比快速排序长。更多的时候我们使用哪一种是通过输入数据的特征以及主存容量是否宝贵来决定的。当我们需要原址排序或者主存容量宝贵的时候我们就更倾向于快速排序这样的原址排序。
————————————————
版权声明：本文为CSDN博主「TimeTDIT」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_35580883/article/details/79114134