排序算法之基数排序

基数排序（Radix Sort）

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

原理：

1、0-9十个数组（桶）
第一次按个位排序：个位的数字是多少就放入哪个数组，所有元素放入数组之后，依次从第0个数组中取出。
第二次按百位排序：
第三次按千位排序
排序得到次数和数组元素的最大位数有关。

图片来自网络，侵删

public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {23,6,189,45,8,287,56,1,798,34,65,652,5};
        radixSort(arr);
    }
    public static void radixSort(int[] arr)
    {
        //首先获取数组元素的最大值
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>max)
            {
                max=arr[i];
            }
        }
        //获取最大值的位数，用以循环的次数
        int maxLength = (max + "").length();

        //定义一个二维数组，用于存储每次排序取到的元素
        //0-9共10个桶固定的，每个桶的大小不确定会取到多少个，但是最大不会超过原数组的长度
        int[][] temp = new int[10][arr.length];
        //定义每个桶当前的长度
        int[] counts = new int[10];//初始化之后每个元素默认为0。所以需要记录每个桶的长度

        //进行maxLength次排序,i=0,n=1,i=1,n=10,i=2,n=100···
        for(int i=0,n=1;i<maxLength;i++,n*=10)
        {
            for(int j=0;j<arr.length;j++)
            {
                int ys = arr[j] / n % 10;
                temp[ys][counts[ys]]=arr[j];
                counts[ys]++;
            }                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
            /*查看第一次排序之后的结果
            if(i==0)
            {
                for (int[] nums :temp)
                {
                    System.out.println(Arrays.toString(nums));
                }
            }*/

            //从二维数组中取出当前排序完的数据
            int index=0;//记录取出元素的长度
            for(int k=0;k<counts.length;k++)
            {
                if(counts[k]!=0)
                {
                    for(int l=0;l<counts[k];l++)
                    {
                        arr[index++]=temp[k][l];
                    }
                }
                //将记录每个桶大小的数据清零。
                //二维数组不需要清除，因为每次都是依靠counts记录的大小取出指定的个数，多余的数不会取到。
                counts[k]=0;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

基数排序使用队列实现：

public class RadixQueueSort {
    public static void main(String[] args) {
        int[] arr = {23,6,189,45,8,287,56,1,798,34,65,652,5};
        radixSort(arr);
    }
    public static void radixSort(int[] arr)
    {
        //首先获取数组元素的最大值
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>max)
            {
                max=arr[i];
            }
        }
        //获取最大值的位数，用以循环的次数
        int maxLength = (max + "").length();

        //将二位数字替换为队列存储元素
        MyQueue[] temp = new MyQueue[10];
        //为每个队列初始化
        for (int i = 0; i < temp.length; i++) {
            temp[i]=new MyQueue();
        }

        //进行maxLength次排序,i=0,n=1,i=1,n=10,i=2,n=100···
        for(int i=0,n=1;i<maxLength;i++,n*=10)
        {
            for(int j=0;j<arr.length;j++)
            {
                int ys = arr[j] / n % 10;
                temp[ys].add(arr[j]);
            }


            //从队列中取出当前排序完的数据
            int index=0;//记录取出元素的长度
            for(int k=0;k<temp.length;k++)
            {
                while(!temp[k].isEmpty())
                {
                    arr[index++]=temp[k].poll();
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}