图解排序算法--基数排序

目录

一、基数排序介绍

二、基数排序基本思想

三、基数排序的说明:

---

看这篇文章很形象

原文链接：https://blog.csdn.net/weixin_42369886/article/details/104875038

一、基数排序介绍

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
基数排序法是属于稳定性的排序，基数排序法是效率高的稳定性排序法。
基数排序(Radix Sort)是桶排序的扩展，它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。

二、基数排序基本思想

将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。这样说明，比较难理解，下面我们看一个图文解释，理解基数排序的步骤。

将数组 {53, 3, 542, 748, 14, 214} 使用基数排序, 进行升序排序。

第1轮排序 [按照个位排序]:
说明： 事先准备10个数组(10个桶)， 0-9 分别对应 位数的 0-9
(1) 将 各个数，按照个位大小 放入到 对应的 各个数组中
(2) 然后从 0-9 个数组/桶中依次按照加入元素的先后顺序取出
第1轮排序后：542 53 3 14 214 748

第2轮排序 [按照十位排序]
(1) 将 各个数，按照十位大小 放入到 对应的 各个数组中
(2) 然后从 0-9 个数组/桶中依次按照加入元素的先后顺序取出
第2轮排序后： 3 14 214 542 748 53

 

第3轮排序 [按照百位排序]
(1) 将 各个数，按照百位大小 放入到 对应的 各个数组中
(2) 然后从 0-9 个数组/桶中依次按照加入元素的先后顺序取出
第3轮排序后：3 14 53 214 542 748 （得到了我们要的顺序） 

代码实现：

  public class RadixSort {
    public static void main(String[] args) {
    int arr[]={53, 3, 542, 748, 14, 214};
    radixSort(arr);
    }

    public static void  radixSort(int[] arr){
        //先求出数组中的最大的数
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        //得到最大数是几位数
        int maxLength=(max+"").length();

        //定义一个二维数组，表示10个桶，每个桶就是一个数组
        //为了在放入数时防止数据溢出，我们每个桶的大小为arr.length,即每个桶最多放进数组里的所有元素
        int[][] bucket=new int[10][arr.length];

        //定义一个一维数组来记录各个桶的每次放入的数据个数
        int[] bucketElementCount=new int[10];

  //第1轮：针对每个元素的个位进行排序处理
        for(int j=0;j<arr.length;j++){
            //取出每个元素的个位进行排序处理
            int digitOfElement=arr[j]/1%10;
            //放入到个位数对应的桶中
            bucket[digitOfElement][bucketElementCount[digitOfElement]]=arr[j];
            bucketElementCount[digitOfElement]++;
        }
        //按照一维数组的下标（即桶的顺序）依次取出数据，放入到原来数组
        int index=0;
        //遍历每一个桶，并将桶中数据放入到原数组
        for(int k=0;k<bucketElementCount.length;k++){
            //如果桶中有数据，才放入原来数组
            if(bucketElementCount[k]!=0){
                for(int m=0;m<bucketElementCount[k];m++){
                   arr[index++]=bucket[k][m];
                     }
               }
               //第一轮处理后，需将bucketElementCount[k]=0
               bucketElementCount[k]=0;
        }
        System.out.println("第1轮，对个位数的排序处理 arr="+ Arrays.toString(arr));



    //第2轮：针对每个元素的十位进行排序处理
        for(int j=0;j<arr.length;j++){
        //取出每个元素的十位进行排序处理
        int digitOfElement=arr[j]/10%10;
        //放入到个位数对应的桶中
        bucket[digitOfElement][bucketElementCount[digitOfElement]]=arr[j];
        bucketElementCount[digitOfElement]++;
    }
    //按照一维数组的下标（即桶的顺序）依次取出数据，放入到原来数组
     index=0;
    //遍历每一个桶，并将桶中数据放入到原数组
        for(int k=0;k<bucketElementCount.length;k++){
        //如果桶中有数据，才放入原来数组
        if(bucketElementCount[k]!=0){
            for(int m=0;m<bucketElementCount[k];m++){
                arr[index++]=bucket[k][m];
            }
        }
        //第2轮处理后，需将bucketElementCount[k]=0
        bucketElementCount[k]=0;
      }
        System.out.println("第2轮，对个位数的排序处理 arr="+ Arrays.toString(arr));

       //第3轮：针对每个元素的百位进行排序处理
        for(int j=0;j<arr.length;j++){
            //取出每个元素的十位进行排序处理
            int digitOfElement=arr[j]/100%10;
            //放入到个位数对应的桶中
            bucket[digitOfElement][bucketElementCount[digitOfElement]]=arr[j];
            bucketElementCount[digitOfElement]++;
        }
        //按照一维数组的下标（即桶的顺序）依次取出数据，放入到原来数组
        index=0;
        //遍历每一个桶，并将桶中数据放入到原数组
        for(int k=0;k<bucketElementCount.length;k++){
            //如果桶中有数据，才放入原来数组
            if(bucketElementCount[k]!=0){
                for(int m=0;m<bucketElementCount[k];m++){
                    arr[index++]=bucket[k][m];
                }
            }
            //第2轮处理后，需将bucketElementCount[k]=0
            bucketElementCount[k]=0;
        }
        System.out.println("第3轮，对个位数的排序处理 arr="+ Arrays.toString(arr));


    }

}

 代码简化：

public class RadixSort {
    public static void main(String[] args) {
    int arr[]={53, 3, 542, 748, 14, 214};
    radixSort(arr);
    }

    public static void  radixSort(int[] arr){
        //先求出数组中的最大的数
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        //得到最大数是几位数
        int maxLength=(max+"").length();

        //定义一个二维数组，表示10个桶，每个桶就是一个数组
        //为了在放入数时防止数据溢出，我们每个桶的大小为arr.length,即每个桶最多放进数组里的所有元素
        int[][] bucket=new int[10][arr.length];

        //定义一个一维数组来记录各个桶的每次放入的数据个数
        int[] bucketElementCount=new int[10];

        for(int i=0,n=1;i<maxLength;i++,n*=10){
            //对每个元素的对应位进行处理
            for(int j=0;j<arr.length;j++){
                //取出每个元素的对应位的值
                int digiOfElement=arr[j]/n%10;
                //放入到对应的桶中
                bucket[digiOfElement][bucketElementCount[digiOfElement]]=arr[j];
                bucketElementCount[digiOfElement]++;
            }
            //按照这个桶的顺序即一维数组的下标一次取出数据放入原来数组
            int index=0;
            //遍历每一桶，并将桶中数据放入到原数组
            for(int k=0;k<bucketElementCount.length;k++){
                //如果桶中有数据，才放入原来数组
                if(bucketElementCount[k]!=0){
                    for(int m=0;m<bucketElementCount[k];m++){
                        arr[index++]=bucket[k][m];
                    }
                }
                //每一轮处理后，需将bucketElementCount[k]=0
                bucketElementCount[k]=0;
            }
            System.out.println("第"+(i+1)+"轮，对个位数的排序处理 arr="+ Arrays.toString(arr));
        }

    }

}

运行结果：

 

三、基数排序的说明:

(1)基数排序是对传统桶排序的扩展，速度很快。
(2)基数排序是经典的空间换时间的方式，占用内存很大, 当对海量数据排序 时，容易造成 OutOfMemoryError 。
(3)基数排序时稳定的。（注:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，如原始数组为{1,3,2,3,5}经过排序后为{1,2,3,3,5},此时第一个3经过排序后仍然在第二个三的前面，则称这种排序算法是稳定的；否则称为不稳定的）。
(4)有负数的数组，我们不用基数排序来进行排序。
 

还可以参考这篇，也很形象，总结下来，1）根据个位数排序一轮，2）根据十位数再排序一轮，3)百位排序。。。。。直到排完为止。

https://blog.csdn.net/weixin_44537194/article/details/87302788