算法

要点：利用空间换时间，有桶排序的思想，按照基数规则转换，使空间开销较小，但理解起来比计数排序复杂的多。

import java.util.Random;

public class RadixSort {

    public void sort(int arr[]) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        // 计数
        int[] bucketArr;
        // 输出
        int[] outputArr = new int[arr.length];
        // 根据最大值求指数
        int exp = (int) Math.pow(10, String.valueOf(max).length() - 1);
        for (int i = 1; i <= exp; i *= 10) {
            bucketArr = new int[10];
            for (int j = 0; j < arr.length; j++) {
                int index = arr[j] / i % 10;
                bucketArr[index]++;
            }
            printArr(bucketArr, " => 计数bucket");
            // 转换 => 见转换说明
            for (int j = 1; j < 10; j++) {
                bucketArr[j] += bucketArr[j - 1];
            }
            printArr(bucketArr, " => 转换bucket");
            // 根据转换后的bucket数组，将原数组的值映射到output数组 => 见映射说明
            // 注意采用的是倒序遍历 => 见倒序说明
            for (int j = arr.length - 1; j >= 0; j--) {
                int index = arr[j] / i % 10;
                int outputIndex = bucketArr[index]--;
                outputArr[outputIndex - 1] = arr[j];
            }
            printArr(outputArr," => output数组");
            for (int j = 0; j < outputArr.length; j++) {
                arr[j] = outputArr[j];
            }
        }
    }

    private void printArr(int[] arr, String message) {
        for (int n : arr) {
            System.out.print(n + ",");
        }
        System.out.println(message);
    }

    public static void main(String[] args) {
        int capacity = 10;
        int[] arr = new int[capacity];
        for (int i = 0; i < capacity; i++) {
            arr[i] = new Random().nextInt(500);
        }
        RadixSort rs = new RadixSort();
        rs.printArr(arr, " => 原数组");
        rs.sort(arr);
        rs.printArr(arr, " => 排序后数组");
    }

    /**
     * 转换说明：
     * 0,1,0,0,2,4,0,2,1,0, => 计数bucket
     * 转换公式：bucekt[i] += bucket[i - 1]
     * 0,1,1,1,3,7,7,9,10,10, => 转换bucket
     * 说白了就是为了统计到[i]位置，bucket获取的元素数
     *
     * 映射说明：
     * 45,5,21,245,454,204,138,137,77,445, => 原数组
     * 0,1,1,1,3,7,7,9,10,10, => 转换bucket
     * 当前的exp是1：
     * 首先计算原数组中的值在bucket哪个位置：=> index = 445 / 1 % 10 = 5
     * 找到bucket[5]对应的值是7，7代表的是个数，因此要减去1才代表下标。
     * out[6] = 445
     * 21,454,204,45,5,245,445,137,77,138, => output数组
     *
     * 倒序说明：
     * 204,5,21,137,138,45,245,445,454,77, => 按照十位已经排好序了
     * 此时，数组十位是有序状态，【从小到大】。
     * 4,2,2,0,2,0,0,0,0,0, => 计数bucket => 其中5,21,45,77在0坐标处计数，为4
     * 4,6,8,8,10,10,10,10,10,10, => 转换bucket
     * 求百位时，所有的个位和十位在求对应的bucket位置时都是0。
     * 如果按正序遍历，就相当于按照从大到小的顺序填入output数组。
     * 如正序遍历，拿到5，求得bucket坐标是0，读取值4，坐标为3，output[3]=5，读取值-1
     * 继续遍历到21，求得bucket坐标是0，读取值3，坐标为2，output[2]=21，读取值-1
     * 顺序反了，因此需要倒序遍历。
     *
     * 利用空间换时间，但是利用了转换规则，使空间开销较小
     * => 遍历了exp * (4m + 10) 次
     * => 时间复杂度O(n) => exp还是有限的
     * => 稳定性：稳定 => 都是整数
     *
     */

}