基数排序----桶排序的扩展

基数排序

public class RadixSort {

    public static void main(String[] args) {
        int[] array = {0,-1,10,7,20,60,11};
        radixSortDesc(array);
        radixSortAsc(array);
    }

    /**
     * 基数排序：降序
     * @param array
     */
    public static void radixSortDesc(int[] array) {
        int max = max(array);
        //获取数组中最大数的位数
        int maxLength = String.valueOf(max).length();
        int min = min(array);
        if (min < 0) {
            reduceMin(array,min);
        }

        int[][] bucket = new int[10][array.length];
        int[] bucketElementCount = new int[10];
        for (int i = 0, n = 1; i < maxLength;i++, n *= 10) {
            for (int data : array) {
                int digit = data / n % 10;
                bucket[digit][bucketElementCount[digit]] = data;
                bucketElementCount[digit]++;
            }
            int index = 0;
            for (int j = 0;j < bucket.length;j++) {
                if (bucketElementCount[j] != 0) {
                    for (int k = 0; k < bucketElementCount[j]; k++) {
                        array[index] = bucket[j][k];
                        index++;
                    }
                }
                bucketElementCount[j] = 0;
            }

        }
        if (min < 0) {
            addMin(array,min);
        }

        System.out.println(Arrays.toString(array));

    }

    /**
     * 获取数组的最大值
     * @param array
     * @return
     */
    public static int max(int[] array) {
        int max = 0;
        for (int data : array) {
            if (max < data) {
                max = data;
            }
        }
        return max;
    }

    /**
     * 获取数组的最小值
     * @param array
     * @return
     */
    public static int min(int[] array) {
        int minValue = 0;
        for (int data : array) {
            if (minValue > data) {
                minValue = data;
            }
        }
        return minValue;
    }


    /**
     * 数组每个元素减去最小值
     * @param array
     * @param minValue
     * @return
     */
    public static int[] reduceMin(int[] array,int minValue) {
        for (int i = 0 ;i < array.length; i++) {
            array[i] -= minValue;
        }
        return array;
    }

    /**
     * 数组每个元素加上最小值
     * @param array
     * @param minValue
     * @return
     */
    public static int[] addMin(int[] array,int minValue) {
        for (int i = 0 ;i < array.length; i++) {
            array[i] += minValue;
        }
        return array;
    }

    /**
     * 基数排序：升序
     * @param array
     */
    public static void radixSortAsc(int[] array) {
        int max = max(array);
        //最大数的长度，即最大的数是几位数
        int maxLength = String.valueOf(max).length();
        int min = min(array);
        if (min < 0) {
            reduceMin(array, min);
        }
        //每个桶里面的元素个数
        int[] bucketElementCounts = new int[10];
        //桶 0 - 9
        int[][] bucket = new int[10][array.length];

        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            for (int data : array) {
                int digit = data / n % 10;
                bucket[digit][bucketElementCounts[digit]] = data;
                bucketElementCounts[digit]++;
            }

            int index = 0;
            for (int k = bucket.length - 1; k >= 0  ;k--) {
                if (bucketElementCounts[k] != 0) {
                    for (int j = 0; j < bucketElementCounts[k] ; j++) {
                        array[index] = bucket[k][j];
                        index++;
                    }
                }
                bucketElementCounts[k] = 0;
            }
        }

        if (min < 0) {
            addMin(array, min);
        }
        System.out.println(Arrays.toString(array));
    }
}