java 基数排序实现

不同于 希尔排序，快速排序这些，基数排序的思想更容易理解，代码也更容易实现。但是基数排序的缺点也很明显，对于小数的处理，需要一些额外的操作。

可以给全部元素进行扩大化处理，但是要考虑大数的溢出问题。…

以下是对基数排序的介绍：

基数排序（英语：Radix sort）是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。
它是这样实现的：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
from : 基数排序

那么处理方法也很简单(假设数组中的元素全部是正整数)：

1. 定义 10个数组，分别对应 [0,9]，这里称每个数组为桶。
2. 然后是判断每个元素的个位数的值，然后把该元素存放到对应的桶里面去。比如27的个位数的值就是7，这样，就把这个27 放到第7个桶（从0开始计数）的第一个位置上; (假设还要一个元素是57，这样就把57放到第7个桶的第二个位置上。)直到遍历完数组的全部元素。
3. 依次取出每个桶里面的全部元素，分别放到原始数组里面去。从原始0的位置开始放，依次递增；
4. 然后是再来一次存桶，取元素的操作，这次判断的值是每个元素的十位数了。（还是以27为例，那么十位数就是2，那么27 这次应该是要放进第2个桶里面去）；
5. 重复步骤4，假设这个数组中最大的元素是618，那么进行到百位数的存取之后，排序就结束了。

下面是代码实现：

    public static void radixSort(int[] array) {
        int[] deeps = new int[9 + 10]; // [-9, 9]
        int[][] buckets = new int[deeps.length][array.length];
        int factor = 1;
        final int mod = 10;
        int overflow;
        int restoreIndex;
        do {
            overflow = 0;
            // step 01, put ele to buckets;
            // noinspection ForLoopReplaceableByForEach
            for (int i = 0; i < array.length; ++i) {
                int digit = array[i] / factor % mod;  // now digit in [-9, 9] --> 2
                // System.out.printf("ele=%d, factor=%d, digit=%d\n", array[i], factor, digit);
                digit += 9; // [-9, 9] -> [0, 18]
                buckets[digit][deeps[digit]++] = array[i];
                // check when to exit the while loop.
                if (array[i] < factor) {
                    overflow++;
                }
            }

            // step 02, get ele from buckets, and restore to origin array
            restoreIndex = 0;
            for (int i = 0; i < buckets.length; ++i) {
                for (int deep = 0; deep < deeps[i]; ++deep) {
                    array[restoreIndex++] = buckets[i][deep];
                }
                deeps[i] = 0; // restore index
            }
            factor *= 10;
            // 这样会多跑一次 do {} while(); 
            // 如果提前计算出最大值的最大位数，可以避免这一次，感觉差别不大，就没有去这样处理
        } while (overflow < array.length);
    }

这里的实现 扩展了对负数部分的处理：如果要考虑负数，桶要增加9个，分别放[-9，-1] 之间的元素。

调用如下：

int[] array = {2, -199, 312, -41, 5, -618, 7, 813, 8, 9, 9, 7, -866, 9, 0};
radixSort(array);

输出如下：

radixSort: before: [2, -199, 312, -41, 5, -618, 7, 813, 8, 9, 9, 7, -866, 9, 0]	 size=15
radixSort:  after: [-866, -618, -199, -41, 0, 2, 5, 7, 7, 8, 9, 9, 9, 312, 813]	 size=15