【数据结构与算法(Java)】排序-基数排序（优化版桶排序）

1. 排序思路

1. 获得最大数的位数
2. 新建：桶数组 + 桶数据记录数组
3. 循环，入桶+出桶
   3.1 入桶：每个数据分别入相应的桶
   3.2 出桶：遍历所有的桶，按桶的顺序依次取出数据，并放入原数组

2. 代码实现

    /**
     * 基数排序
     * 思路：
     *      1. 获得最大数的位数
     *      2. 新建：桶数组 + 桶数据记录数组
     *      3. 循环，入桶+出桶
     *        3.1 入桶：每个数据分别入相应的桶
     *        3.2 出桶：遍历所有的桶，按桶的顺序依次取出数据，并放入原数组
     * @param array - 要排序的数组
     * @return - 排序后数组（不改变原始数组）
     */
    public static int[] radixSort(int[] array) {
        // 1. 复制数组
        int[] sortedArray = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            sortedArray[i] = array[i];
        }

        // 2. 获得最大数的位数
        // 2.1 获得最大数
        int maxNumber = sortedArray[0];
        for (int number : sortedArray) {
            if (number > maxNumber) {
                maxNumber = number;
            }
        }
        // 2.2 储存最大数的位数
        int maxDigit = (maxNumber + "").length();

        // 3. 新建：桶数组 + 桶数据记录数组
        // 3.1 共10个桶，每个桶均为一个二维数组，用来放置数据
        int[][] bucketArray = new int[10][sortedArray.length];
        // 3.2 一维数组，大小为10，分别存放每个桶的有效数据数目
        int[] bucketNumberCountArray = new int[10]; // 1

        // 4. 循环，入桶+出桶
        // digitCount：当前计数（遍历几次）， digit：当前位数
        for (int digitCount = 0, digit = 1; digitCount < maxDigit; digitCount++, digit *= 10) {
            // 4.1 入桶：每个数据分别入相应的桶
            for (int arrayCount = 0; arrayCount < sortedArray.length; arrayCount++) {
                // (1) 获取当前位数的数字
                int digitOfNumber = sortedArray[arrayCount] / digit % 10;
                // (2) 入桶，并计数
                bucketArray[digitOfNumber][bucketNumberCountArray[digitOfNumber]] = sortedArray[arrayCount];
                bucketNumberCountArray[digitOfNumber]++;
            }
            // 4.2 出桶：遍历所有的桶，按桶的顺序依次取出数据，并放入原数组
            int arrayCount = 0;
            for (int bucketCount = 0; bucketCount < bucketArray.length; bucketCount++) {
                // 若当前桶非空，则取出桶内所有数据
                if (bucketNumberCountArray[bucketCount] != 0) {
                    for (int validNumberCount = 0; validNumberCount < bucketNumberCountArray[bucketCount]; validNumberCount++) {
                        sortedArray[arrayCount++] = bucketArray[bucketCount][validNumberCount];
                    }
                    // 清空当前桶的计数
                    bucketNumberCountArray[bucketCount] = 0;
                }
            }
        }

        // 5. 返回排好序的数组
        return sortedArray;
    }
}