基数排序

一.基本思想

利用多关键字的划分，逐渐将待排序列排好序。

二.基数排序举例

现在有数组：278，109，63,930,589,184,505,269,8,83
第一次根据个位数将数组划分为10个队列(当然其中的某些队列可能不含有元素)
队列0：930
队列1：
队列2：
队列3：63，83
队列4：184
队列5：505
队列6：
队列7：
队列8：278,8
队列9：109,589,269

然后收集成序列：
930，63，83，184，505，278，8，109，589，269

进行第二次分配：
队列0：505，8，109
队列1：
队列2：
队列3：930
队列4：
队列5：
队列6：63，269
队列7：278
队列8：83，184，589
队列9：

第二次收集：
505，8，109，930，63，269，278，83，184，589

第三次分配：
队列0：8,63,83
队列1：109,184
队列2：278,269
队列3：
队列4：
队列5：505,589
队列6：
队列7：
队列8：
队列9：930

最后得到序列：
8，63，83，109，184，269，278，505，589，930
完成排序！

三.基数排序的Java实现

    /**
     * 基数排序
     * @param array
     */
    public static void raidxSort(int[] array){
        //首先确定排序的趟数：先找到最大的数，然后求出最大数的位数
        int max = getmax(array);
        int trips = getDigits(max);
        //建立10个队列，并初始化
        List<Integer>[] lists = new LinkedList[10];
        for (int i = 0; i < lists.length; i++) {
            lists[i] = new LinkedList<Integer>();
        }
        for(int i=0; i<trips; i++){
            //分配数组元素
            for(int j=0; j<array.length; j++){
                //得到i+1位数，及首先得到个位数，然后得到十位数，依此类推
                int digits =  (array[j] % (int)Math.pow(10, i+1)) / (int)Math.pow(10, i);
                lists[digits].add(array[j]);
            }
            //收集数组元素
            int index=0;//待排序的数组的下标
            for(int k=0; k<10; k++){
                if(!lists[k].isEmpty()){
                    while(lists[k].size()>0){
                        array[index++] = lists[k].removeFirst();
                    }
                }
            }
        }
    }

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

    /**
     * 获取某一个正整数的位数
     * @param number
     * @return
     */
    public static int getDigits(int number){
        int digits = 0;
        while(number>0){
            number/=10;
            digits++;
        }
        return digits;
    }

四.效率

O(k*n)，k为关键字的个数

五.应用场景

数据明显有几个关键字或者几个属性组成