1. public class RadixSort {
    2.     public static void main(String[] args) {
    3.         int[] arr = {53, 3, 542, 748, 14, 214};
    5.         radixSort(arr);
    6.     }
    9.     //基数排序方法
    10.     public static void radixSort(int[] arr) {
    12.         //第1轮（针对每个元素的个位进行排序处理）
    14.         //定义一个二维数组，表示10个桶，每个桶就是一个一维数组
    15.         //说明
    16.         //1.二维数组包含10个一位数组
    17.         //2.为了防止在放入数的时候，数据溢出，则每个一位数组(桶)，大小定为arr.length
    18.         //3.基数排序是使用空间换时间的经典算法
    19.         int[][] bucket = new int[10][arr.length];//桶
    21.         //为了记录每个桶中，实际存放了多少个数据，我们定义一个一维数组来记录各个桶的每次放入的数据个数
    22.         //可以这样理解
    23.         //比如： bucketElementCounts[0], 记录的就是 bucket[0] 桶的放入数据个数
    24.         int[] bucketElementCounts = new int[10];//每个桶中数据的个数
    26.         //第1轮（针对每一元素的个位进行排序处理）
    27.         for (int j = 0; j < arr.length; j++) {
    28.             //取出每个元素的个位的值
    29.             int digitOfElement = arr[j] / 1 % 10;//有规律
    30.             //放入到对应的桶中
    31.             bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
    32.             bucketElementCounts[digitOfElement]++;
    33.         }
    34.         //按照这个桶的顺序（按一维数组的下标依次取出数据，放入原来数组）
    35.         int index = 0;
    36.         //遍历每一个桶，并将桶中的数据，放入到原数组
    37.         for (int k = 0; k < bucketElementCounts.length; k++) {
    38.             //如果桶中，有数据，我们才放入到原数组
    39.             if (bucketElementCounts[k] != 0) {
    40.                 //循环该桶，即第k个桶
    41.                 for (int l = 0; l < bucketElementCounts[k]; l++) {
    42.                     //取出元素放入到arr
    43.                     arr[index] = bucket[k][l];
    44.                     index++;
    45.                 }
    46.             }
    48.             //第1轮处理后，需要将每个bucketElementCounts[k] = 0 ！！！
    49.             bucketElementCounts[k] = 0;
    52.         }
    54.         System.out.println("第1轮: " + Arrays.toString(arr));
    57.         //*************************************************************************
    60.         //第2轮（针对每一元素的十位进行排序处理）
    61.         for (int j = 0; j < arr.length; j++) {
    62.             //取出每个元素的个位的值
    63.             int digitOfElement = arr[j] / 10 % 10;
    64.             //放入到对应的桶中
    65.             bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
    66.             bucketElementCounts[digitOfElement]++;
    67.         }
    68.         //按照这个桶的顺序（按一维数组的下标依次取出数据，放入原来数组）
    69.         index = 0;
    70.         //遍历每一个桶，并将桶中的数据，放入到原数组
    71.         for (int k = 0; k < bucketElementCounts.length; k++) {
    72.             //如果桶中，有数据，我们才放入到原数组
    73.             if (bucketElementCounts[k] != 0) {
    74.                 //循环该桶，即第k个桶
    75.                 for (int l = 0; l < bucketElementCounts[k]; l++) {
    76.                     //取出元素放入到arr
    77.                     arr[index] = bucket[k][l];
    78.                     index++;
    79.                 }
    80.             }
    82.             //第2轮处理后，需要将每个bucketElementCounts[k] = 0 ！！！
    83.             bucketElementCounts[k] = 0;
    85.         }
    87.         System.out.println("第2轮: " + Arrays.toString(arr));
    90.         //*************************************************************************
    93.         //第3轮（针对每一元素的百位进行排序处理）
    94.         for (int j = 0; j < arr.length; j++) {
    95.             //取出每个元素的个位的值
    96.             int digitOfElement = arr[j] / 100 % 10;
    97.             //放入到对应的桶中
    98.             bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
    99.             bucketElementCounts[digitOfElement]++;
    100.         }
    101.         //按照这个桶的顺序（按一维数组的下标依次取出数据，放入原来数组）
    102.         index = 0;
    103.         //遍历每一个桶，并将桶中的数据，放入到原数组
    104.         for (int k = 0; k < bucketElementCounts.length; k++) {
    105.             //如果桶中，有数据，我们才放入到原数组
    106.             if (bucketElementCounts[k] != 0) {
    107.                 //循环该桶，即第k个桶
    108.                 for (int l = 0; l < bucketElementCounts[k]; l++) {
    109.                     //取出元素放入到arr
    110.                     arr[index] = bucket[k][l];
    111.                     index++;
    112.                 }
    113.             }
    115.             //第3轮处理后，需要将每个bucketElementCounts[k] = 0 ！！！
    116.             bucketElementCounts[k] = 0;
    118.         }
    120.         System.out.println("第3轮: " + Arrays.toString(arr));
    123.     }
    124. }

    image.png