算法：基数排序

最新推荐文章于 2024-06-20 23:50:49 发布

OceanStar的学习笔记

最新推荐文章于 2024-06-20 23:50:49 发布

阅读量2.2k

点赞数

分类专栏：算法与数据结构文章标签：算法排序算法 java

原文链接：https://www.iteye.com/blog/128kj-1681186

版权

算法与数据结构专栏收录该内容

1135 篇文章 82 订阅

订阅专栏

引入

如果要对6个3位整数进行排序，你会怎么做？

我猜想大多数人会这样做：

123  123  123 

343  135  135

362  241  241

241  343  343

135  362  352

352  352  362

先对高位进行排序，然后对高位相同的，次高位进行排序，一直进行到低位。

基数排序进行排序的方向一般有两种方式:

高位优先(MSD)：从高位到低位依次对序列排序
低位优先(LSD)：从低位到高位依次对序列排序

计算机一般采用低位优先法（人类一般使用高位优先），

低位优先可以按照下面的一组数字做出说明：12、 104、 13、 7、 9

按个位数排序是12、13、104、7、9
再根据十位排序104、7、9、12、13
再根据百位排序7、9、12、13、104

这里注意，如果在某一位的数字相同，那么排序结果要根据上一轮的数组确定，举个例子来说：07和09在十分位都是0，但是上一轮排序的时候09是排在07后面的；同样举一个例子，12和13在十分位都是1，但是由于上一轮12是排在13前面，所以在十分位排序的时候，12也要排在13前面。

所以，一般来说，10基数排序的算法应该是这样的？

判断数据在各位的大小，排列数据；
根据1的结果，判断数据在十位的大小，排列数据。如果数据在这个位置的余数相同，那么数据之间的顺序根据上一轮的排列顺序确定；
依次类推，继续判断数据在百位、千位…上面的数据重新排序，直到所有的数据在某一位上数据都为0。

图示

示例一：

LSD
在这里插入图片描述

示例二

动图

思想

基数排序的思路是：是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
基数排序可以说是扩展了的桶式排序，比如当待排序列在一个很大的范围内，比如0到999999内，那么用桶式排序是很浪费空间的。而基数排序把每个排序码拆成由d个排序码，比如任何一个6位数（不满六位前面补0）拆成6个排序码，分别是个位的，十位的，百位的。。。。排序时，分6次完成，每次按第i个排序码来排。

基数排序一般借助桶式排序，每次按第N位排序时，采用桶式排序。对于如何安排每次落入同一个桶中的数据有两种安排方法：

顺序存储：每次使用桶式排序，放入r个桶中，相同时增加计数。
链式存储：每个桶通过一个静态队列来跟踪。

步骤：

得到数组中的最大数，并取得位数
arr为原始数据，从最低位开始取每个为组成radix数组；
对radix进行基数排序（利用计数排序适用于小范围数的特点）；

实现

 // w为第几位
   private static void countSort(int[] arr, int w){
        // 初始化一个桶
        List<ArrayList<Integer>> buckets = new ArrayList<ArrayList<Integer>>();
        // 可能位数为0-9，所以设置10个桶
        for (int i = 0; i < 10; i++){
            buckets.add(new ArrayList<Integer>()); //桶由ArrayList<Integer>构成
        }

        // 遍历原始数组，将数组的各个位分配到相应桶中
        for (int j = 0; j < arr.length; j++){
            //取出该元素对应第i+1位上的数字，比如258，现在要取出十位上的数字，258%100=58,58/10=5
            //取出该元素对应第i+1位上的数字，比如258，现在要取出十位上的数字，258%100=58,58/10=5
            int key =arr[j]%(int)Math.pow(10, w+1)/(int)Math.pow(10, w);
            buckets.get(key).add(arr[j]); //将该元素放入关键字为key的桶中
        }

        // 分配好桶之后，将桶中的元素依次复制回数组
        //分配完之后，将桶中的元素依次复制回数组
        int counter = 0; //元素计数器
        for(int j=0;j<10;j++){
            ArrayList<Integer> bucket =buckets.get(j); //关键字为j的桶
            while(bucket.size()>0){
                arr[counter++] = bucket.remove(0); //将桶中的第一个元素复制到数组，并移除
            }
        }
    }


    public static void radixSort2(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }
        // 求出数组的最大值
        int  max = Integer.MIN_VALUE;
        for (int num:arr){
            if (num > max){
                max = num;
            }
        }

        // 求最大值的位数
        int keysnums = (max + "").length();
        for (int i = 0; i < keysnums; i++){
            countSort(arr, i);
        }
    }

    //基于桶排序的基数排序算法
    private static void radixSort(int[] array,int radix, int distance) {
        //array为待排序数组
        //radix，代表基数 (桶的个数）
        //代表排序元素的位数

        int length = array.length;
        int[] temp = new int[length];//用于暂存元素
        int[] count = new int[radix];//用于桶排序
        int divide = 1;

        for (int i = 0; i < distance; i++) {

            System.arraycopy(array, 0,temp, 0, length);
            Arrays.fill(count, 0);

            for (int j = 0; j < length; j++) {
                int tempKey = (temp[j]/divide)%radix;
                count[tempKey]++;
            }

            for (int j = 1; j < radix; j++) {
                count [j] = count[j] + count[j-1];
            }

            //重点在下面这个方法
            for (int j = length - 1; j >= 0; j--) {
                int tempKey = (temp[j]/divide)%radix;
                count[tempKey]--;
                array[count[tempKey]] = temp[j];
            }

            divide = divide * radix;

        }

    }




    public static void main(String[] args) {
        int[] arr = new int[]{3,2,3,2,5,333,45566,2345678,78,990,12,432,56};
        radixSort(arr, 10, 7);
        System.out.println(Arrays.toString(arr));
    }

我自己的实现

使用条件

基数排序对要排序的数据是有要求的，需要可以分割出独立的“位”来比较，而且位之间有递进的关系，如果 a 数据的高位比 b 数据大，那剩下的低位就不用比较了。
除此之外，每一位的数据范围不能太大，要可以用线性排序算法来排序，否则，基数排序的时间复杂度就无法做到 O(n) 了。

性能分析

计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。

实际应用

假设我们有10万个手机号码，希望这10万个手机号码从小到大排序，那应该怎么排序呢？

分析：

不能用桶排序和计数排序，因为手机号码有11位，范围太大。这个时候可以使用基数排序。
针对这个问题，假设要比较两个手机号码a、b的大小，如果在前面几位中，a手机号码已经比b手机号码大了，那号码几位就不用看了。
借助稳定排序算法，我们可以先按照最后一位来排序手机号码，然后，再按照倒数第二位来重新排序，以此类推，最后按照第一位重新排序。经过11次排序之后，手机号码就有序了。
注意，这里按照每位来排序的排序算法必须是稳定的，否则这个实现思路就是不正确的。因为如果是非稳定的排序算法，那最好一次排序只会考虑最高位的大小顺序，完全不管其他位的大小关系
按照每一位来排序，我们可以用桶排序或者计数排序，它们的时间复杂度可以做到O(n)。如果要排序的数据有k位，那我们就需要k次桶排序或者计数排序，总的时间复杂度是O(k*n)。当k不大的时候，比如手机号码排序的例子，k 最大就是 11，所以基数排序的时间复杂度就近似于 O(n)。

步骤：