基数排序(桶排序)介绍

（1）基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用。

（2）基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法。

（3）基数排序(Radix Sort)是桶排序的扩展。

（4）基数排序是1887年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。
 

 步骤

1.找待排序元素中最大的数，确定其位数。

2.准备10个数组， 0-9分别对应位数的0-9。

3.将所有待排序元素的个位数分别放入对应的0-9数组中。再从0-9的数组中依次从下标为0取出放入原待排序数组中。

4.将所有待排序元素的十位数分别放入对应的0-9数组中。再从0-9的数组中依次取出放入原待排序数组中。

5.将所有待排序元素的百位数分别放入对应的0-9数组中。再从0-9的数组中依次取出放入原待排序数组中。

......

6.直到最大位进行上述操作后，排序完成。

动图演示

 算法代码

public static void basicSort(int[] elem) {
        //1. 找最大值
        if(elem.length == 0) return;
        int max = elem[0];
        for (int i = 0; i < elem.length; i++) {
            if(max < elem[i]) {
                max = elem[i];
            }
        }

        // 2.确定最大值的位数
        int num = 0;
        while(max > 0) {
            max/=10;
            num++;
        }


        //3. 创建10个数组

        int[][] array = new int[10][elem.length];
        int x = 0;
        while(num > 0) {
            int i0=0,i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0,i8=0,i9=0;

            //放入
            for (int i = 0; i < elem.length; i++) {
                int tmp = (elem[i]/(int)Math.pow(10,x)) % 10;

                switch(tmp) {
                    case 0: array[0][i0] = elem[i];i0++; break;
                    case 1: array[1][i1] = elem[i];i1++; break;
                    case 2: array[2][i2] = elem[i];i2++; break;
                    case 3: array[3][i3] = elem[i];i3++; break;
                    case 4: array[4][i4] = elem[i];i4++; break;
                    case 5: array[5][i5] = elem[i];i5++; break;
                    case 6: array[6][i6] = elem[i];i6++; break;
                    case 7: array[7][i7] = elem[i];i7++; break;
                    case 8: array[8][i8] = elem[i];i8++; break;
                    case 9: array[9][i9] = elem[i];i9++; break;
                }
            }


            // 2.取出排序
            int j = 0;

            int tmp0 = i0;
            while(i0 >0) {
                elem[j] = array[0][tmp0-i0];
                i0--;
                j++;
            }
            int tmp1 = i1;
            while(i1 >0) {

                elem[j] = array[1][tmp1-i1];
                i1--;
                j++;
            }
            int tmp2 = i2;
            while(i2 >0) {
                elem[j] = array[2][tmp2-i2];
                i2--;
                j++;
            }
            int tmp3 = i3;
            while(i3 >0) {

                elem[j] = array[3][tmp3-i3];
                i3--;
                j++;
            }
            int tmp4 = i4;
            while(i4 >0) {

                elem[j] = array[4][tmp4-i4];
                i4--;
                j++;
            }
            int tmp5 = i5;
            while(i5 >0) {

                elem[j] = array[5][tmp5-i5];
                i5--;
                j++;
            }
            int tmp6 = i6;
            while(i6 >0) {

                elem[j] = array[6][tmp6-i6];
                i6--;
                j++;
            }
            int tmp7 = i7;
            while(i7 >0) {

                elem[j] = array[7][tmp7-i7];
                i7--;
                j++;
            }
            int tmp8 = i8;
            while(i8 >0) {

                elem[j] = array[8][tmp8-i8];
                i8--;
                j++;
            }
            int tmp9 = i9;
            while(i9 >0) {

                elem[j] = array[9][tmp9-i9];
                i9--;
                j++;
            }


            x++;
            num--;

        }

    }

测试打印

public static void main(String[] args) {

        int arr[] = {45,98,36,85,20,99,79,96,12,13,52,66,88,10,30};
        basicSort(arr);
        for (int i: arr) {
            System.out.print(i+" ");
        }
    }

基数排序说明

（1）基数排序是对传统桶排序的扩展，速度很快；

（2）基数排序是经典的空间换时间的方式，占用内存很大, 当对海量数据排序时，容易造成 OutOfMemoryError；

（3）基数排序时稳定的。[注:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的] ；

（4）有负数的数组，我们不用基数排序来进行排序,