经典排序算法--基数排序

基本思想：

　　基数排序是另外一种比较有特色的排序方式，它不需要直接对元素进行相互比较，也不需要将元素相互交换，你需要做的就是对元素进行“分类”。它是怎么排序的呢？

　　

　　基数排序（以整形为例），将整形10进制按每位拆分，然后从低位到高位依次比较各个位。主要分为两个过程：

　　(1)分配，先从个位开始，根据位值(0-9)分别放到0~9号桶中（比如53,个位为3，则放入3号桶中）

　　(2)收集，再将放置在0~9号桶中的数据按顺序放到数组中

　　重复(1)(2)过程，从个位到最高位（比如32位无符号整形最大数4294967296，最高位10位）

　　

　　例如现在我们要将下列一组数进行排序： {13,25,1111,232,4454,79,86,98,61,447};

　　1）先按照各位数字进行排序，排序后结果为{1111,61,232,13,4454,25,86,447,98,79}

　　2) 然后再按照十位进行排序，排序结果为{1111，13，25，232，447，4454，61，79，86，98}

　　3）然后按照百位进行排序，如果百位为空，则认为百位为0，排序结果为{13，25，61，79，86，98，1111，232，447，4454}

　　4）最后按照千位排序，排序结果为{13,25,61,79,86,98,232,447,1111,4454}

java代码实现：

　　

public class BaseSort {
    public static void main(String[] args) {
        int[] a = {13,25,1111,232,4454,79,86,98,61,447};
        System.out.println("初始值:");
        print(a);
        a=sort(a);
        System.out.println("\n排序后:");
        print(a);
    }
    
    
    public static int[]  sort(int[] data){
        int maxLength = getMaxLength(data);
        int[] tmp = baseSort(data,0,maxLength);
        return tmp;
    }
    
    /**
     * @param data
     * @param i
     * @param maxLength
     * @return
     */
    private static int[] baseSort(int[] data, int i, int maxLength) {
        if(i>=maxLength){
            return data;
        }
        int len = data.length;
        
        //创建10个桶，每个桶中分别用来存放第i位为0~9得数子个数
        //例如i=0,count[1],就用来存放各位为1得数字个数
        int[] count = new int[10];
        //用来复制数组，辅助排序
        int[] tmp = new int[len]; 
        
        //将数组中所有得数按照规则放入同种
        for (int j = 0; j < tmp.length; j++) {
            count[getNum(data[j], i)]++;
        }
        
        //将count[]数字代表桶中数字得个数，变为下标
        //例如：count[0]原来为1个，count[1]为1个，那么count[1]后面一位得下表就是count[0]+count[1]=2
        for (int j = 1; j < count.length; j++) {
            count[j] = count[j-1]+count[j];
        }
        //将原数组总元素按照顺序复制到新数组中
        for (int j = tmp.length-1; j >= 0; j--) {
            int number = data[j];
            int a = getNum(number, i);
            tmp[count[a]-1]=number;
            count[a]--;
        }
        return baseSort(tmp, i+1, maxLength);
    }


    /**
     * 获取一个数字第i位得数字,个位从0开始
     * @param num
     * @param i
     * @return
     */
    private static int getNum(int num,int i){
        for (int j = 0; j < i+1; j++) {
            if(j==i){
                num%=10;
            }else{
                num=num/10;
            }
        }
        return num;
    }
    
    /**
     * 获取数组得长度
     * @param num
     * @return
     */
    private static int length(int num){
        return String.valueOf(num).length();
    }
    
    /**
     * 查找数组总所有得元素拥有得最大长度
     * @param data
     * @return
     */
    private static int getMaxLength(int[] data){
        int maxLength = 0 ;
        for (int i = 0; i < data.length; i++) {
            if(maxLength<length(data[i])){
                maxLength = length(data[i]);
            }
        }
        return maxLength;
    }
    
    private static void print(int[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"  ");
        }
        System.out.println();
    }
}