排序-基数排序RadixSort

一、基数排序(桶排序)介绍:

1)基数排序(radixsort)属于“分配式排序”(distributionsort) ，又称“桶子法”(bucket sort)或binsort，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用.
2)基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
3)基数排序(Raditsort)是桶排序的扩展
4)基数排序是1887年赫尔曼.何乐礼发明的。它是这样实现的:将整数按位数切割成不同的数字，然后按每个位数分别比较。

二、基数排序逻辑结构示意图

第一轮

第二轮

第三轮

三、代码实现与截图

分步排序

package sort;

import java.util.Arrays;

public class RadixSortTest {
    public static void main(String[] args){

        //创建一个一维数组，存放要排序的数
        int[] arr = {53,3,542,748,14,214};
        RadixSort(arr);

    }


    //定义基数排序
    public static void RadixSort(int[] arr){
        //定义一个二维数组，表示10个桶（0-9），每个桶就是一个一维数组，来存放数据
        int[][] bucket = new int[10][arr.length];

        //定义一个一维数组，10个桶，用来记录每个桶中元素的个数
        int[] count = new int[10];

        //第一轮排序（个位）
        for (int j = 0 ; j <arr.length ;j++){

            //比较个位
            int num = arr[j]/1%10;
            //放入对应的桶中的相应位置
            bucket[num][count[num]++] = arr[j];

        }

        //按照桶的顺序，即一维数组count的下标，依次取出里面的数据
        int index = 0;//桶的下标
        //遍历每个桶，拿到对应的数，放回源数组
        for (int m=0;m<count.length;m++){
            //如果桶中有数据，取出
            if (count[m] != 0){
                //循环这些有数据的桶，放入
                for (int n = 0 ;n<count[m];n++){
                    //取出元素，放入arr中
                    arr[index++] = bucket[m][n];
                }
            }
            count[m] =0;
        }
        System.out.println("第一轮，对个位排序处理 arr = "+ Arrays.toString(arr));

        //第二轮排序（十位）
        for (int j = 0 ; j <arr.length ;j++){

            //比较个位
            int num = arr[j]/10%10;
            //放入对应的桶中的相应位置
            bucket[num][count[num]++] = arr[j];

        }

        //按照桶的顺序，即一维数组count的下标，依次取出里面的数据
        index = 0;//桶的下标
        //遍历每个桶，拿到对应的数，放回源数组
        for (int m=0;m<count.length;m++){
            //如果桶中有数据，取出
            if (count[m] != 0){
                //循环这些有数据的桶，放入
                for (int n = 0 ;n<count[m];n++){
                    //取出元素，放入arr中
                    arr[index++] = bucket[m][n];
                }
            }
            count[m] =0;
        }
        System.out.println("第二轮，对十位排序处理 arr = "+ Arrays.toString(arr));


        //第三轮排序（百位）
        for (int j = 0 ; j <arr.length ;j++){

            //比较个位
            int num = arr[j]/100%10;
            //放入对应的桶中的相应位置
            bucket[num][count[num]++] = arr[j];

        }

        //按照桶的顺序，即一维数组count的下标，依次取出里面的数据
        index = 0;//桶的下标
        //遍历每个桶，拿到对应的数，放回源数组
        for (int m=0;m<count.length;m++){
            //如果桶中有数据，取出
            if (count[m] != 0){
                //循环这些有数据的桶，放入
                for (int n = 0 ;n<count[m];n++){
                    //取出元素，放入arr中
                    arr[index++] = bucket[m][n];
                }
            }
            count[m] =0;
        }
        System.out.println("第三轮，对百位排序处理 arr = "+ Arrays.toString(arr));

    }

}

最终代码

package sort;

import java.util.Arrays;

public class RadixSortTest {
    public static void main(String[] args){

        //创建一个一维数组，存放要排序的数
        int[] arr = {53,3,542,748,14,214};
        RadixSort(arr);

    }


    //定义基数排序
    public static void RadixSort(int[] arr) {

        //找出arr数组中最大的数
        int maxNum = arr[0];//假设第一个最大
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > maxNum) {
                maxNum = arr[i + 1];
            }
        }
        //确认最大数的位数，这就决定了要执行的轮数
        int maxNumLength = (maxNum + "").length();


        //定义一个二维数组，表示10个桶（0-9），每个桶就是一个一维数组，来存放数据
        int[][] bucket = new int[10][arr.length];

        //定义一个一维数组，10个桶，用来记录每个桶中元素的个数
        int[] count = new int[10];

        //处理的轮数
        for (int i = 0; i < maxNumLength; i++) {
            //依次按照个位，十位，百位大小排序
            for (int j = 0; j < arr.length; j++) {

                //依次比较个位，十位，百位
                int num = arr[j] /(int)(Math.pow(10,i)) % 10;
                //放入对应的桶中的相应位置
                bucket[num][count[num]++] = arr[j];
            }

            //按照桶的顺序，即一维数组count的下标，依次取出里面的数据
            int index = 0;//桶的下标
            //遍历每个桶，拿到对应的数，放回源数组
            for (int m = 0; m < count.length; m++) {
                //如果桶中有数据，取出
                if (count[m] != 0) {
                    //循环这些有数据的桶，放入
                    for (int n = 0; n < count[m]; n++) {
                        //取出元素，放入arr中
                        arr[index++] = bucket[m][n];
                    }
                }
                count[m] = 0;
            }
            System.out.println("第"+(i+1)+"轮，对个位排序处理 arr = " + Arrays.toString(arr));
        }
    }

}

截图实现