基数排序

基数排序

基于桶式排序，将要排序的数字一位一位的比较，经历多次桶式排序，得出最终的序列
如果要排序的元素可以分成多位，并且每一位都在一个固定的范围内，则可以用这种排序方法，如对10进制数字的排序

有数字23,35,9,73,3,314,11,1234,5，可以看出来，每一位数字的取值范围都是0到9，所以我们可以用10个桶来进行排序，分别编号0到9。

①第一遍排序，按照最低位数字将各个数字存入桶中：

桶号	0	1	2	3	4	5	6	7	8	9
存放数字	11	23,73,3	314,1234	35,5	9

按照桶的序号将所有的数字倒出来，对于一个桶内有多个数字的情况，我们按照先进先出的原则倒出数字：

桶的倒出顺序	数字队列
9	9
8	9
7	9
6	9
5	9,35,5
4	9,35,5,314,1234
3	9,35,5,314,1234,23,73,3
2	9,35,5,314,1234,23,73,3
1	9,35,5,314,1234,23,73,3,11
0	9,35,5,314,1234,23,73,3,11

我们可以看大第一遍排序好的数字还是很乱的，可能还不能基数排序的妙处，不急，下面我们进行第二次排序

②第二遍排序，将第一次排好的序列9,35,5,314,1234,23,73,3,11，按照第二位的数字存入桶中（只有一位的数第二位为0）：

桶号	0	1	2	3	4	5	6	7	8	9
存放数字	9,5,3	314,11	23	35,1234				73

按照桶的序号将所有的数字倒出来，对于一个桶内有多个数字的情况，我们按照先进先出的原则倒出数字：

桶的倒出顺序	数字队列
9
8
7	73
6	73
5	73
4	73
3	73,35,1234
2	73,35,1234,23
1	73,35,1234,23,314,11
0	73,35,1234,23,314,11,9,5,3

我们发现，第二遍之后，有些数字好像已经排序好了，经过两次排序，或许你已经能看出来一些基数排序的原理了，下面我们进行第三遍排序

③第三遍排序，将第二次排好的序列73,35,1234,23,314,11,9,5,3，按照第三位的数字存入桶中（只有两位的数第三位为0）：

桶号	0	1	2	3	4	5	6	7	8	9
存放数字	73,35,23,11,9,5,3	1234		314

按照桶的序号将所有的数字倒出来，对于一个桶内有多个数字的情况，我们按照先进先出的原则倒出数字：

桶的倒出顺序	数字队列
9
8
7
6
5
4
3	314
2	314,1234
1	314,1234
0	314,1234,73,35,23,11,9,5,3

第三遍排序结束，相信你已经看出来基数排序到底是个什么东西了，如果你还不懂，后面会有一个flash，清晰明了的一步一步为你分解基数排序，在这之前，让我们先勤勤恳恳的把第四遍，也是最后一遍排序完成

④第四遍排序，将第三次排好的序列314,1234,73,35,23,11,9,5,3，按照第四位的数字存入桶中（只有三位的数第四位为0）：

桶号	0	1	2	3	4	5	6 7 8 9
存放数字	314,73,35,23,11,9,5,3	1234

按照桶的序号将所有的数字倒出来，对于一个桶内有多个数字的情况，我们按照先进先出的原则倒出数字：

桶的倒出顺序	数字队列
9
8
7
6
5
4
3
2
1	1234
0	1234,314,73,35,23,11,9,5,3

至此，我们终于完成了排序。

代码示例

/**
 * 基数排序
 * 
 * @author yangpeng
 *
 */
public class RadixSortDemo {

    public static void main(String[] args) {
        int[] a = { 2, 7, 8, 3, 10, 62, 92, 0, 5, 4 };
        System.out.println("初始序列:" + Arrays.toString(a));
        RadixSort(a, getMaxWei(a));
        System.out.println("最后:" + Arrays.toString(a));
    }

    /**
     * 
     * @param a
     *            需要排序的数组
     * @param d
     *            数组 的最大位数
     */
    public static void RadixSort(int[] a, int d) {

        // 二维数组 temp用来保存当前的排序的数字
        // 第一维 10 表示一共有10个桶
        // 第二维a.length 表示每个桶最多可能存放a.length个数字
        int[][] temp = new int[10][a.length + 1];
        int[] order = new int[10];
        for (int pos = 1; pos <= d; pos++) {
            // 将数据分配到每个桶中
            for (int i = 0; i < order.length; i++) {
                int row = getMaxPos(a[i], pos);// 第一个桶
                int col = ++order[row];// 桶的数据+1;
                temp[row][col] = a[i];

            }

            for (int i = 0; i < temp.length; i++) {
                System.out.print(i + "个桶 ");
                for (int j = 0; j < temp[i].length; j++) {
                    System.out.print(temp[i][j] + "  ");
                }
                System.out.print("order:" + order[i]);
                System.out.println();

            }

            int k = 0;
            for (int i = 0; i < order.length; i++) {
                if (order[i] != 0) {
                    // 存在相应的值
                    for (int j = 1; j <= order[i]; j++) {
                        a[k] = temp[i][j];
                        k++;
                    }
                }
                order[i] = 0;
            }
            System.out.println(pos + "最后:" + Arrays.toString(a));
        }
    }

    /**
     * 求当前数 的在指定位置的余数
     * 
     * @param num
     *            带求的数
     * @param pos
     *            位数 1表示个位， 2表示十位， 3表示百位
     * @return 返回余数
     */
    public static int getMaxPos(int num, int pos) {
        int temp = 1;
        for (int i = 0; i < pos - 1; i++) {
            temp *= 10;
        }
        return (num / temp) % 10;
    }

    /**
     * 求数组的位数
     * 
     * @param a
     *            带求的数组
     * @return 返回数组的最大位数
     */
    public static int getMaxWei(int[] a) {
        int max = a[0];
        // 先找到a数组的最大值
        for (int i = 1; i < a.length; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }

        int temp = 1, d = 1;
        while (true) {
            temp *= 10;
            if (max / temp != 0) {
                d++;
            } else {
                break;
            }
        }
        return d;
    }

}