java实现基数排序

package com.atguigu.Sort;

import java.util.Arrays;

/**
 * @author shkstart
 * @create 2021 -11-04 19:58
 */
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){
        //最终基数排序代码
        //1.得到数组中最大位数,先假设最大为arr[0]
        int max = arr[0];
        for(int i = 1;i < arr.length;i++){
            if(max < arr[i]){
                max = arr[i];
            }
        }
        //得到最大数是几位数
        int maxLength = (max + "").length();
//        定义一个二维数组，表示10个桶，每个桶就是一个一维数组
//        说明：
//        1.二维数组包含10个一维数组
//        2.为了防止在放入数的时候数据溢出，则每个一位数组(桶)，大小定为arr.length
//        3.基数排序是空间换时间的经典算法
        int[][] bucket = new int[10][arr.length];

//        为了记录每个桶中，实际存放了多少个数据，我们定义一个一维数组来记录各个桶每次放入的数据个数
//        可以这样理解
//        bucketElementCounts[0],记录的就是bucket[0]桶存放的数据个数
        int[] bucketElementCounts = new int[10];
        //这里我们使用循环将代码处理
        for(int i = 0,n = 1;i < maxLength;i++,n*=10){
            //针对每个元素的对应位进行排序处理，第一次是个位，第二次是十位...
            for(int j = 0;j < arr.length;j++){
                //取出每个元素对应位的值
                 int digitOfElement = arr[j]/n%10;
                //放入到对应的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
            bucketElementCounts[digitOfElement]++;
            }
            //按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
        int index = 0;
           //遍历每一个桶，并将桶中的数据，放入到原来数组
        for(int k = 0;k < bucket.length;k++){
//            //如果桶中有数据，我们才放入原数组
            if(bucketElementCounts[k] != 0){
                //循环该桶即第k个桶(即第一个一维数组),放入
                for(int l = 0;l < bucketElementCounts[k];l++){
                    //取出元素放入到arr中
                    arr[index++] = bucket[k][l];
                }
            }
            //经过一轮处理后，需将bucketElementCounts[k]归零
            bucketElementCounts[k] = 0;
        }
        System.out.println("第"+ (i+1) +"轮对位数的排序处理arr=" + Arrays.toString(arr));

        }





        //第一轮：针对每个元素的个位数进行排序

        //定义一个二维数组，表示10个桶，每个桶就是一个一维数组
        //说明：
        //1.二维数组包含10个一维数组
        //2.为了防止在放入数的时候数据溢出，则每个一位数组(桶)，大小定为arr.length
        //3.基数排序是空间换时间的经典算法
//        int[][] bucket = new int[10][arr.length];

        //为了记录每个桶中，实际存放了多少个数据，我们定义一个一维数组来记录各个桶每次放入的数据个数
        //可以这样理解
        //bucketElementCounts[0],记录的就是bucket[0]桶存放的数据个数
//        int[] bucketElementCounts = new int[10];

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


    }
}