基数排序（Java实现）

一：基本思想

        1.基数排序也是桶排序的扩展

        2.将数组所有的数据统一长度，位不足的数在前面补0

        3.通过得到各个位的值，将元素分配进一些桶中，达到排序作用

        4.基数排序是属于效率高且稳定的排序

二：举例讲解

       列举几个数：

int[] arr={53,3,542,728,14,214};

 1.首先确定最大的数是728，有个位，十位，百位

 2.确定位数后，不足十位和百位的数，在前面补0

 3.比较数组中的个位数，按照顺序放到对应的桶中(每个桶都是一个一维数组)，全部放进去后，再取出来重新排序

按照个位数放入桶中后得到的顺序为

 542，53，3，14，214，728

4.然后再依次比较十位数，放到对应的桶中（没有十位的补0）

按照十位数放入桶中得到的顺序位：
3，14，214，728，542，53

5.再依次比较百位数，放到对应的桶中（没有百位的同样补0）

按照百位数放入桶中得到的顺序为：

3，14，53，214，542，728

从最低位开始排序，一直排到最高位完成以后，就成为了一个有序序列

三：代码示例

import java.util.Arrays;

public class RadixSort {
    public static void main(String[] args) {
        int arr[]={53,3,542,728,14,214};
        radixSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    //基数排序的方法（空间换时间的经典算法）
    public static void radixSort(int[] arr){
        //找到数组中最大的数
        //判断元素最多是多少位数
        int max=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max<arr[i]){
                max=arr[i];
            }
        }
        int maxLength=(max+"").length();
        //第一轮，针对每个元素个位进行处理,第二轮，针对每个元素十位进行处理，第三轮，针对每个元素百位进行处理
        //定义一个二维数组，表示十个桶，每个桶就是一个一维数组
        //为防止溢出，每个桶长度就是数组最大长度
        int[][] bucket=new int[10][arr.length];
        //记录每个桶中实际存放了多少数据，定义一个一维数组记录每个桶中存放的数据元素
        int[] bucketElementCounts=new int[10];
        for (int i = 0,n=0; i < maxLength; i++,n++) {
            //第i轮，对每个元素数据各位进行排序处理，取出然后放入到不同个位数桶中
            for (int j = 0; j < arr.length; j++) {
                int digitOfElemnt= (int) (arr[j]/Math.pow(10, n) % 10);
                //放入到对应桶中
                bucket[digitOfElemnt][bucketElementCounts[digitOfElemnt]]=arr[j];
                bucketElementCounts[digitOfElemnt]++;
            }
            //按照桶的顺序，取出通里所有的数，放回到原来的数组中
            int index=0;
            //遍历每一个桶，并将桶中的数据放入到原数组
            for (int k = 0; k < bucketElementCounts.length; k++) {
                //判断每个桶里面是否有数据
                if(bucketElementCounts[k] != 0){
                    //如果有数据，遍历取出桶里面数据放到数组里面
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        arr[index++]=bucket[k][l];
                    }
                }
                //每轮处理完成后，将每桶置为空
                bucketElementCounts[k]=0;
            }
            System.out.println("第"+(i+1)+"轮排序结果是"+Arrays.toString(arr));
        }
    }
}

部分讲解：

（1）定义的二维数组，共有十个桶，每个桶里面可能放N个数据

一维数组用来统计每个桶里面存放了多少个数据

int[][] bucket=new int[10][arr.length];
int[] bucketElementCounts=new int[10];

（2）利用平方，根据外层的循环分别取出个位，十位，百位的数判断放在哪个桶中

int digitOfElemnt= (int) (arr[j]/Math.pow(10, n) % 10);

其他的注释基本能看懂

结果打印：

第1轮排序结果是[542, 53, 3, 14, 214, 728]
第2轮排序结果是[3, 14, 214, 728, 542, 53]
第3轮排序结果是[3, 14, 53, 214, 542, 728]
最终结果[3, 14, 53, 214, 542, 728]