【经典排序】之基数排序

一.算法描述

• 设置一个定量的数组当作空桶， 遍历数据 把数据一个一个放到对应的桶里去；

• 对非空的桶进行排序；

• 非空桶里把数据拼接起来。

二.代码实现

   public int[] sort(int[] nums) {
        int maxNumber = getMaxNumber(nums);
        return radixSort(nums, maxNumber);
    }

    private int getMaxNumber(int[] nums) {
        int maxNumber = getMaxValue(nums);
        return getNumLenght(maxNumber);
    }

    private int getMaxValue(int[] arr) {
        int maxValue = arr[0];
        for (int value : arr) {
            if (maxValue < value) {
                maxValue = value;
            }
        }
        return maxValue;
    }

    protected int getNumLenght(long num) {
        if (num == 0) {
            return 1;
        }
        int lenght = 0;
        for (long tmp = num; tmp != 0; tmp /= 10) {
            lenght++;
        }
        return lenght;
    }

    private int[] radixSort(int[] arr, int maxNumber) {
        int mod = 10;
        int dev = 1;

        for (int i = 0; i < maxNumber; i++, dev *= 10, mod *= 10) {
            int[][] counter = new int[mod * 2][0];

            for (int j = 0; j < arr.length; j++) {
                int bucket = ((arr[j] % mod) / dev) + mod;
                counter[bucket] = fillArray(counter[bucket], arr[j]);
            }

            int pos = 0;
            for (int[] bucket : counter) {
                for (int value : bucket) {
                    arr[pos++] = value;
                }
            }
        }

        return arr;
    }

    private int[] fillArray(int[] nums, int value) {
        nums = Arrays.copyOf(nums, nums.length + 1);
        nums[nums.length - 1] = value;
        return nums;
    }

三.复杂度分析

时间复杂度：O(n*k）

空间复杂度：O(n+k）

稳定性：稳定