3.基数排序

基数排序，也叫桶排序(空间换时间的算法), 注意：如果排序的数很大的话，可能内存溢出。不能有负数，如果要支持负数的话需要取绝对值，在给他倒转

桶排序的实现：

1.先找到最大的数

2.找到最大数的位数

3.定义一个二维数组，二维数组里面的每个数代表一个桶，定义一个数组，里面放的是记录的次数

4.进行循环，循环的次数是最大的位数的长度， 先找个位，在找10位，百位。。。。依次找下去

1）先找到个位，找个个位的桶，放进去

2）再根据桶的排序，给他拿出来，赋给原来的数组

5.桶排序其实就是先个位排序，再十位排序，接着百位，千位

public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {1, 789, 56, 23, 55, 4, 9, 73, 22};
        radixSort(arr);
    }

    //基数排序的方法
    public static void radixSort(int[] arr) {
//        1.得到最大数
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

//        2.得到最大数的位数
        int maxLength = (max + "").length();

        //定义一个二维数组，表示10个桶，每个桶就是一维数组
        int[][] bucket = new int[10][arr.length];

        //记录每个桶中，实际存放了多少个数据，定义一个一维数组来记录每次放入的个数
        int[] bucketElementCounts = new int[10];
        for (int a = 0, n = 1; a < maxLength; a++, n *= 10) {
            //第i轮，针对个位数排序 ,比如说 第一轮判断的是第一轮是个位，第二轮是百位，以此添加
            for (int i = 0; i < arr.length; i++) {
                //取出每个元素的个位数的值
                int digitOfElement = arr[i] / n % 10;
                //放入对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[i];
                bucketElementCounts[digitOfElement]++;
            }
            //按照这个桶的顺序（一维数组的下标依次取出数据，放到原来的数组中）
            int index = 0;
            //遍历每一桶，并将桶中的数据，放入到原来的数组中
            for (int k = 0; k < bucketElementCounts.length; k++) {
                //如果桶中，有数据，放入到原来的数组中
                if (bucketElementCounts[k] != 0) {
                    //循环该桶的第k个桶，放入
                    for (int j = 0; j < bucketElementCounts[k]; j++) {
                        arr[index++] = bucket[k][j];
                    }
                }
                //把桶的数据清空
                bucketElementCounts[k] = 0;
            }
            System.out.println("第" + (a + 1) + "轮排序的结果是：" + Arrays.toString(arr));
        }
    }
}