基数排序 (Radix Sort)

算法原理
———————————————————————————————————
基数排序 (Radix Sort) 是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。
————
排序过程：将所有待比较数值（必须是正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序；然后从桶中倒出所有数，完成一次排序；依次迭代到高位，这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
————
基数排序法会使用到桶 (Bucket)，顾名思义，通过将要比较的位（个位、十位、百位…），将要排序的元素分配至 0~9 个桶中，借以达到排序的作用，在某些时候，基数排序法的效率高于其它的比较性排序法。
————
注：基数排序要满足的条件<1>必须是正整数；<2>从低位开始判断，一直迭代到最高位；<3>采用稳定排序。

多关键字排序时有两种解决方案：
最高位优先法（MSD）(Most Significant Digit first)
最低位优先法（LSD）(Least Significant Digit first)
例如，对如下数据序列进行排序。
192,221,12,23
可以观察到它的每个数据至多只有3位，因此可以将每个数据拆分成3个关键字：百位（高位）、十位、个位（低位）。
如果按照习惯思维，会先比较百位，百位大的数据大，百位相同的再比较十位，十位大的数据大；最后再比较个位。人得习惯思维是最高位优先方式。
如果按照人得思维方式，计算机实现起来有一定的困难，当开始比较十位时，程序还需要判断它们的百位是否相同–这就认为地增加了难度，计算机通常会选择最低位优先法。
基数排序方法对任一子关键字排序时必须借助于另一种排序方法，而且这种排序方法必须是稳定的。
对于多关键字拆分出来的子关键字，它们一定位于0-9这个可枚举的范围内，这个范围不大，因此用桶式排序效率非常好。
对于多关键字排序来说，程序将待排数据拆分成多个子关键字后，对子关键字排序既可以使用桶式排序，也可以使用任何一种稳定的排序方法。

此处给出两种实现方法：
<1>采用计数排序来实现基数排序，上一篇中有去实现过计数排序的实现，个人感觉计数排序所选择的桶有可能太多，因为是对于待排序中的最大值和最小值的差距个桶，基数排序所选的桶则为0-9号桶，对于每一位都采用计数排序，则能排好每一位的数，然后利用基数排序从低位到高位的迭代就可以完成排序。从时间和空间上都有所提升。

package 排序;

import java.util.Arrays;

public class RadixSort {


    //基于计数排序的基数排序算法 
    private static void radixSort(int[] array,int radix, int distance) {  
        //array为待排序数组 
        //radix，代表基数 
        //代表排序元素的位数 

        int length = array.length;  
        int[] temp = new int[length];//用于暂存元素 
        int[] count = new int[radix];//用于计数排序 
        int divide = 1;  

        for (int i = 0; i < distance; i++) {  

            System.arraycopy(array, 0,temp, 0, length);  
            Arrays.fill(count, 0);  

            for (int j = 0; j < length; j++) {  
                int tempKey = (temp[j]/divide)%radix;  
                count[tempKey]++;  
            }  

            for (int j = 1; j < radix; j++) {  
                count [j] = count[j] + count[j-1];  
            }  

            //运用计数排序实现基数排序的重点在下面这个方法 
            for (int j = length - 1; j >= 0; j--) {  
                 //这个必须从后面算，因为count统计的是总数
                int tempKey = (temp[j]/divide)%radix;  
                count[tempKey]--;  
                array[count[tempKey]] = temp[j];  
            }  

            divide = divide * radix;                  

        }  

    }  


    /** * @param args */  
    public static void main(String[] args) {  

        int[] array = {3,2,3,2,5,333,45566,2345678,78,990,12,432,56};  
        radixSort(array,10,7);  
        for (int i = 0; i < array.length; i++) {  
            System.out.print(" " + array[i]);  
        }  


    }  


}

<2>采用java提供的数据结构Arraylist和LinkedList来实现,具体实现过程中有解释

public static void radixSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int negNum = 0; 
        for (int i = 0; i < arr.length; i++) {
            //统计正负整数的个数
            negNum += arr[i] < 0 ? 1 : 0;
        }
        int[] negArr = new int[negNum];
        int[] posArr = new int[arr.length - negNum];
        int negi = 0;
        int posi = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < 0) {
                negArr[negi++] = -arr[i];
            } else {
                posArr[posi++] = arr[i];
            }
        }
        radixSortForPositive(negArr);
        radixSortForPositive(posArr);
        int index = 0;
        for (int i = negArr.length - 1; i >= 0; i--) {
            arr[index++] = -negArr[i];
        }
        for (int i = 0; i < posArr.length; i++) {
            arr[index++] = posArr[i];
        }
    }

    public static void radixSortForPositive(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        /*这里的数据结构是，ArrayList中存放的是LinkedList，原因是对于每个桶中的元素要进行调整，所以采用LinkedList； 而对于桶与桶之间只需要进行访问操作，所以选取ArrayList。 对于需要快速插入，删除元素，应该使用LinkedList。 对于需要快速随机访问元素，应该使用ArrayList。*/
        ArrayList<LinkedList<Integer>> qArr1 = new ArrayList<LinkedList<Integer>>();
        ArrayList<LinkedList<Integer>> qArr2 = new ArrayList<LinkedList<Integer>>();
        for (int i = 0; i < 10; i++) {
            qArr1.add(new LinkedList<Integer>());
            qArr2.add(new LinkedList<Integer>());
        }
        for (int i = 0; i < arr.length; i++) {
            //arr[i] % 10，得到对应的位上的数，get()找到对应的桶，offer()添加到对应的桶
            qArr1.get(arr[i] % 10).offer(arr[i]);
        }
        long base = 10;
        while (base <= Integer.MAX_VALUE) {
            for (int i = 0; i < 10; i++) {
                //get()找到对应的桶
                LinkedList<Integer> queue = qArr1.get(i);
                while (!queue.isEmpty()) {
                    //倒桶
                    int value = queue.poll();
                    //按从低位到高位迭代
                    qArr2.get((int) (value / base) % 10).offer(value);
                }
            }
            ArrayList<LinkedList<Integer>> tmp = qArr1;
            qArr1 = qArr2;
            qArr2 = tmp;
            base *= 10;
        }
        int index = 0;
        for (int i = 0; i < 10; i++) {
            LinkedList<Integer> queue = qArr1.get(i);
            while (!queue.isEmpty()) {
                arr[index++] = queue.poll();
            }
        }
    }