基数排序

基数排序思想

基数排序是一个经典的空间换时间的排序算法。白话难表达，下面直接上图。

图示 

这里按照 9,  153,  5,  3,  99,  72,  60,  111,  100,  10 该组数字为例进行说明，（从小到大）

1. 定义10个桶，（程序里可以定义二维数组来表示）先将每个数字按照个位数字依次将数字放入桶中（个位数字是几便放在第几个桶中）

2. 然后依次从左至右，从上到下把桶的数取出并放至原数组中，此时数组将变为如下情况。

3. 将上述数组再以十位上的数字依次放入响应的桶中，（位数不足的在前面补零）

4. 再次依次从左至右，从上到下把桶的数取出并放至原数组中，此时数组将变为如下情况。

5. 将上述数组再以百位上的数字依次放入响应的桶中，（位数不足的在前面补零），由于上述数字中百位数字只有0和1，下面只列出下标为 0 和 1 的桶。

6. 最后依次从左至右，从上到下把桶的数取出并放至原数组中，便得到排序好的数组。

总结

根据上述步骤可以看出，每个桶的容量应该为数组的长度，因为有可能数组中所有的数会被装进同一个桶中。并且需要为每个桶定义一个索引用来存取桶中的数。还可以看出装桶出桶的循环的次数应为数组中最大数的位数。若要从大到小排序，则出桶的时候按照从右至左，从上至下的顺序即可。

需要注意的是采用该方法只能排序正数，不能对负数进行排序。如果要支持负数可以为负数在定义一组桶，让负数取绝对值和正数分开排序。最后将负数逆序即可。（具体方法参见下面代码）

 

代码实现

不支持负数的代码：

public static void radixSort(int[] array) {
        //找出数组中最大的数并获取其长度
        int max = array[0];
        for (int i : array) {
            if (max < i) {
                max = i;
            }
        }
        int maxLength = (max + "").length();
        //定义10个桶
        int[][] bucket = new int[10][array.length];
        //定义桶的索引
        int[] curIndex = new int[10];

        for (int i = 0; i < maxLength; i++) {
            //装桶
            for (int j = 0; j < array.length; j++) {
                int bucketIndex = array[j] / (int)Math.pow(10, i) % 10;
                bucket[bucketIndex][curIndex[bucketIndex]] = array[j];
                curIndex[bucketIndex]++;
            }
            //出桶
            int index = 0;
            for (int j = 0; j < bucket.length; j++) {
                if (curIndex[j] > 0) {
                    for (int k = 0; k < curIndex[j]; k++) {
                        array[index] = bucket[j][k];
                        index++;
                    }
                    curIndex[j] = 0;
                }
            }
        }
    }

支持负数的代码：

    //可以处理负数
    public static void radixSort_fu(int[] array) {
        //找出数组中最大的数并获取其长度
        int max = array[0];
        for (int i : array) {
            if (max < i) {
                max = i;
            }
        }
        int maxLength = (max + "").length();

        //为整数和负数分别定义10个桶以及其索引
        int[][] bucket = new int[10][array.length];
        int[][] bucket_fu = new int[10][array.length];
        int[] curIndex = new int[10];
        int[] curIndex_fu = new int[10];
        //统计负数的个数
        int count_fu = 0;

        for (int i = 0; i < maxLength; i++) {
            for (int j = 0; j < array.length; j++) {
                if (array[j] < 0) {
                    //负数装桶
                    count_fu++;
                    int bucketIndex = Math.abs(array[j]) / (int)Math.pow(10, i) % 10;
                    bucket_fu[bucketIndex][curIndex_fu[bucketIndex]] = array[j];
                    curIndex_fu[bucketIndex]++;
                } else {
                    //正数装桶
                    int bucketIndex = array[j] / (int)Math.pow(10, i) % 10;
                    bucket[bucketIndex][curIndex[bucketIndex]] = array[j];
                    curIndex[bucketIndex]++;
                }
            }
            int index = 0;
            //负数出桶
            for (int j = 0; j < bucket_fu.length; j++) {
                if (curIndex_fu[j] > 0) {
                    for (int k = 0; k < curIndex_fu[j]; k++) {
                        array[index] = bucket_fu[j][k];
                        index++;
                    }
                    curIndex_fu[j] = 0;
                }
            }
            //正数出桶
            for (int j = 0; j < bucket.length; j++) {
                if (curIndex[j] > 0) {
                    for (int k = 0; k < curIndex[j]; k++) {
                        array[index] = bucket[j][k];
                        index++;
                    }
                    curIndex[j] = 0;
                }
            }
        }
        
        //将排序好的负数逆序
        int temp;
        for (int i = 0, j = count_fu/maxLength - 1; i < j; i++, j--) {
            temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }