基数排序（Radixsort）

基数排序法属于稳定性排序，是桶排序的扩展，按位数来进行比较，从最低位开始依次进行排序

        int[] arr = new int[20];
        for (int j = 0; j < arr.length; j++) {
            arr[j] = (int) (Math.random() * 10);
        }
        System.out.println(Arrays.toString(arr));
        radixsort(arr);
        System.out.println(Arrays.toString(arr));
 
    }

    public static void radixsort(int[] arr) {
        // 二维数组列代表一个桶，行存储数值
        int[][] bucket = new int[10][arr.length];
        // 负数数组
        int[] neg = new int[arr.length];
        // 一维数组 表示桶中数值的个数
        int[] count = new int[10];
        // 求出最大数的位数
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i])
                max = arr[i];
        }
        int maxlength = String.valueOf(Math.abs(max)).length();
        // 负数个数
        int negnum = 0;

        for (int i = 0, n = 1; i < maxlength; i++, n *= 10) {
            // 遍历数组
            for (int j = negnum; j < arr.length; j++) {
                if (arr[j] >= 0) {
                    int value = arr[j] / n % 10;// 求位数的值
                    bucket[value][count[value]++] = arr[j];
                } else {
                    neg[negnum++] = arr[j];
                }

            }
            // 给负数留位置
            int index = negnum;
            for (int j = 0; j < count.length; j++) {
                if (count[j] != 0) {
                    for (int k = 0; k < count[j]; k++) {
                        arr[index] = bucket[j][k];
                        index++;
                    }
                }
                count[j] = 0;
            }
        }
        // 负数排序
        Arrays.sort(neg);
        int index = 0;
        for (int i = 0; i < negnum; i++) {
            arr[index++] = neg[i];
        }
    }