数据结构与算法：排序算法（二）

前言

本文主要讲解排序算法

---

数据结构与算法文章列表

数据结构与算法文章列表: 点击此处跳转查看

---

目录

---

（一）排序算法的介绍

排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程

常见的排序算法有：冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序等

---

（二）快速排序

（1）快速排序法介绍
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）

快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法

---

（2）快速排序算法步骤

1. 从数列中挑出一个元素，称为 “基准”（pivot）

2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作

3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去

---

（3）快速排序动画

动画解释：

首先，操作数列中的所有数字

在所有数字中选择一个数字作为排序的基准（pivot）, pivot 通常是随机选择的，在这里为了演示方便，我们选择最右边的数字作为 pivot

选取好 pivot 后，在操作数列中选择最左边的数字标记为 左标记 ，最右边的数字标记为 右标记

将左边的标记向右移动

当 左标记 达到超过 pivot 的数字时，停止移动

在这里，8 > 6 ,所以停止移动

然后将右边的标记向左移动

当 右标记 达到小于 pivot 的数字时，停止移动

在这里，4 < 6 ,所以停止移动

当左右标记停止时，更改标记的数字

因此，左标记 的作用是找到一个大于 pivot 的数字，右标记 的作用是找到一个小于 pivot 的数字

通过交换数字，可以在数列的左边收集小于 pivot 的数字集合，右边收集大于 pivot 的数字集合

交换之后，继续移动 左标记

在这里，9 > 6 ,所以停止移动

然后将右边的标记向左移动

当 右标记 碰撞到 左标记 时也停止移动

如果左右侧的标记停止时，并且都在同一个位置，将这个数字和 pivot 的数字交换

这就完成了第一次操作

小于 6 的都在 6 的左侧，大于 6 的都在 6 的右侧

然后递归对这分成的两部分都执行同样的操作

完成 快速排序

---

（4）代码

import java.util.Arrays;
public class QuickSort {

     public static void main(String[] args) {
          int[] arr = {-9, 78, 0, 23, 9, 70, -1, -900, 4561};
          quickSort(arr, 0, arr.length - 1);
          System.out.println("arr=" + Arrays.toString(arr));
     }

     public static void quickSort(int[] arr, int left, int right) {
          int l = left; // 左下标
          int r = right; // 右下标
          // pivot 中轴值
          int pivot = arr[(left + right) / 2];
          int temp = 0; // 临时变量，作为交换时使用
          // while循环的目的是让比pivot值小放到左边
          // 比pivot值大放到右边
          while (l < r) {
              // 在pivot的左边一直找,找到大于等于pivot值,才退出while (arr[l] < pivot) {}这个循环,并且记录此时的arr[l],用于下面的交换
              while (arr[l] < pivot) {
                   l += 1;
              }
              
              // 在pivot的右边一直找,找到小于等于pivot值,才退出while (arr[r] > pivot) {}这个循环,并且记录此时的arr[r],用于下面的交换
              while (arr[r] > pivot) {
                   r -= 1;
              }
              
              // 如果l >= r说明pivot的左右两的值，已经按照左边全部是
              // 小于等于pivot值，右边全部是大于等于pivot值，退出当前while循环
              if (l >= r) {
                   break;
              }
              // 交换
              temp = arr[l];
              arr[l] = arr[r];
              arr[r] = temp;
              
              // System.out.println("arr=" + Arrays.toString(arr));
              // arr=[-9, -900, 0, 23, 9, 70, -1, 78, 4561]
              // arr=[-9, -900, 0, -1, 9, 70, 23, 78, 4561]
              // 注意第二个结果
              // 左边：arr[l] = 0时，0比9小，继续往下走，arr[l] = 23，23比9大，暂停
              // 右边：arr[r] = -1时，-1比9小，暂停
              // 交换
              
              // 下面这两个if语句理解不了
              // 如果交换完后，发现这个arr[l] == pivot值 相等 r--， 前移
              if (arr[l] == pivot) {
                   r -= 1;
              }
              
              // 如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移
              if (arr[r] == pivot) {
                   l += 1;
              }
              
              // 比较此时的l和r，如果l < r，则继续执行while (l < r) {}循环
              
          }
          // 如果 l == r, 必须l++, r--, 否则为出现栈溢出
          if (l == r) {
              l += 1;
              r -= 1;
          }
          
     
          // 向左递归
          if (left < r) {
              quickSort(arr, left, r);
          }
          
          // 向右递归
          if (right > l) {
              quickSort(arr, l, right);
          }
     }
}

结果：

arr=[-900, -9, -1, 0, 9, 23, 70, 78, 4561]

---

代码：（速度测试）

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class QuickSort {

     public static void main(String[] args) {
          // 测试快排的执行速度
          // 创建要给80000个的随机的数组
          int[] arr = new int[8000000];
          for (int i = 0; i < 8000000; i++) {
              arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
          }
          System.out.println("排序前");
          Date data1 = new Date();
          SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
          String date1Str = simpleDateFormat.format(data1);
          System.out.println("排序前的时间是=" + date1Str);
          quickSort(arr, 0, arr.length - 1);
          Date data2 = new Date();
          String date2Str = simpleDateFormat.format(data2);
          System.out.println("排序前的时间是=" + date2Str);
     }

     public static void quickSort(int[] arr, int left, int right) {
          int l = left; // 左下标
          int r = right; // 右下标
          // pivot 中轴值
          int pivot = arr[(left + right) / 2];
          int temp = 0; // 临时变量，作为交换时使用
          // while循环的目的是让比pivot 值小放到左边
          // 比pivot 值大放到右边
          while (l < r) {
              // 在pivot的左边一直找,找到大于等于pivot值,才退出
              while (arr[l] < pivot) {
                   l += 1;
              }
              
              // 在pivot的右边一直找,找到小于等于pivot值,才退出
              while (arr[r] > pivot) {
                   r -= 1;
              }
              
              // 如果l >= r说明pivot 的左右两的值，已经按照左边全部是
              // 小于等于pivot值，右边全部是大于等于pivot值
              if (l >= r) {
                   break;
              }
              // 交换
              temp = arr[l];
              arr[l] = arr[r];
              arr[r] = temp;
              // 如果交换完后，发现这个arr[l] == pivot值 相等 r--， 前移
              if (arr[l] == pivot) {
                   r -= 1;
              }
              
              // 如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移
              if (arr[r] == pivot) {
                   l += 1;
              }
          }
          // 如果 l == r, 必须l++, r--, 否则为出现栈溢出
          if (l == r) {
              l += 1;
              r -= 1;
          }
          
          // 向左递归
          if (left < r) {
              quickSort(arr, left, r);
          }
          
          // 向右递归
          if (right > l) {
              quickSort(arr, l, right);
          }
          
     }
}

结果：（八百万个数，排序时间为2s）

排序前
排序前的时间是=2020-12-23 23:35:21
排序前的时间是=2020-12-23 23:35:23

---

（三）归并排序

（1）归并排序介绍
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

1. 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）
2. 自下而上的迭代

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间

---

（2）归并排序基本思想
申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

设定两个指针，最初位置分别为两个已经排序序列的起始位置；

比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

重复步骤 3 直到某一指针达到序列尾；

将另一序列剩下的所有元素直接复制到合并序列尾

---

（3）归并排序动画

动画解释：

首先，将数字分割成两片区域

再将数字分割成两片区域

依次划分

直到每片区域只有一个元素

分割完成

接下来，将分割的每片区域进行合并组合

合并时，按照数字的升序移动，使得合并后的数字在组内按升序排列

当合并包含多个数字的组时，比较开头的数字，移动其中较小的数字

比如在动画中，比较开头的 4 和 3

其中 4 大于 3， 因此移动 3

按照同样的逻辑去比较该列剩余的头数

4 小于 7 ，所以移动 4

同样的逻辑去进行接下来的操作

递归的重复组的合并操作，直到所有数字都在一个组中。

完成 归并排序

---

（4）代码

package com.lzacking.sort;
import java.util.Arrays;
public class MergetSort {

     public static void main(String[] args) {
          int arr[] = { 8, 4, 5, 7, 1, 3, 6, 2 };
          int temp[] = new int[arr.length]; // 归并排序需要一个额外空间
          mergeSort(arr, 0, arr.length - 1, temp);
          System.out.println("归并排序后=" + Arrays.toString(arr));
     }
     
     // 分+合方法
     public static void mergeSort(int[] arr, int left, int right, int[] temp) {
          if (left < right) {
              int mid = (left + right) / 2; // 中间索引
              // 向左递归进行分解
              mergeSort(arr, left, mid, temp);
              // 向右递归进行分解
              mergeSort(arr, mid + 1, right, temp);
              // 合并
              merge(arr, left, mid, right, temp);
          }
     }
     
     // 合并的方法
     /**
      *
      * @param arr
      *            排序的原始数组
      * @param left
      *            左边有序序列的初始索引
      * @param mid
      *            中间索引
      * @param right
      *            右边索引
      * @param temp
      *            做中转的数组
      */
     public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
          int i = left; // 初始化i, 左边有序序列的初始索引
          int j = mid + 1; // 初始化j, 右边有序序列的初始索引
          int t = 0; // 指向temp数组的当前索引
          // (一)
          // 先把左右两边(有序)的数据按照规则填充到temp数组
          // 直到左右两边的有序序列，有一边处理完毕为止
          while (i <= mid && j <= right) {// 继续
              // 如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
              // 即将左边的当前元素，填充到 temp数组
              // 然后 t++, i++
              if (arr[i] <= arr[j]) {
                   temp[t] = arr[i];
                   t += 1;
                   i += 1;
              } else { // 反之,将右边有序序列的当前元素，填充到temp数组
                   temp[t] = arr[j];
                   t += 1;
                   j += 1;
              }
          }
          // (二)
          // 把有剩余数据的一边的数据依次全部填充到temp
          while (i <= mid) { // 左边的有序序列还有剩余的元素，就全部填充到temp
              temp[t] = arr[i];
              t += 1;
              i += 1;
          }
          while (j <= right) { // 右边的有序序列还有剩余的元素，就全部填充到temp
              temp[t] = arr[j];
              t += 1;
              j += 1;
          }
          // (三)
          // 将temp数组的元素拷贝到arr
          // 注意，并不是每次都拷贝所有
          t = 0;
          int tempLeft = left;
          // 第一次合并 tempLeft = 0 , right = 1
          // tempLeft = 2 right = 3
          // tL=0 ri=3
          // 最后一次 tempLeft = 0 right = 7
          while (tempLeft <= right) {
              arr[tempLeft] = temp[t];
              t += 1;
              tempLeft += 1;
          }
     }
}

---

代码：（归并排序速度测试）

package com.lzacking.sort;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MergetSort {

     public static void main(String[] args) {
          // 测试快排的执行速度
          // 创建要给80000个的随机的数组
          int[] arr = new int[8000000];
          for (int i = 0; i < 8000000; i++) {
              arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
          }
          System.out.println("排序前");
          Date data1 = new Date();
          SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
          String date1Str = simpleDateFormat.format(data1);
          System.out.println("排序前的时间是=" + date1Str);
          int temp[] = new int[arr.length]; // 归并排序需要一个额外空间
          mergeSort(arr, 0, arr.length - 1, temp);
          Date data2 = new Date();
          String date2Str = simpleDateFormat.format(data2);
          System.out.println("排序前的时间是=" + date2Str);
     }
     
     // 分+合方法
     public static void mergeSort(int[] arr, int left, int right, int[] temp) {
          if (left < right) {
              int mid = (left + right) / 2; // 中间索引
              // 向左递归进行分解
              mergeSort(arr, left, mid, temp);
              // 向右递归进行分解
              mergeSort(arr, mid + 1, right, temp);
              // 合并
              merge(arr, left, mid, right, temp);
          }
     }
     
     // 合并的方法
     /**
      *
      * @param arr
      *            排序的原始数组
      * @param left
      *            左边有序序列的初始索引
      * @param mid
      *            中间索引
      * @param right
      *            右边索引
      * @param temp
      *            做中转的数组
      */
     public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
          int i = left; // 初始化i, 左边有序序列的初始索引
          int j = mid + 1; // 初始化j, 右边有序序列的初始索引
          int t = 0; // 指向temp数组的当前索引
          // (一)
          // 先把左右两边(有序)的数据按照规则填充到temp数组
          // 直到左右两边的有序序列，有一边处理完毕为止
          while (i <= mid && j <= right) {// 继续
              // 如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
              // 即将左边的当前元素，填充到 temp数组
              // 然后 t++, i++
              if (arr[i] <= arr[j]) {
                   temp[t] = arr[i];
                   t += 1;
                   i += 1;
              } else { // 反之,将右边有序序列的当前元素，填充到temp数组
                   temp[t] = arr[j];
                   t += 1;
                   j += 1;
              }
          }
          // (二)
          // 把有剩余数据的一边的数据依次全部填充到temp
          while (i <= mid) { // 左边的有序序列还有剩余的元素，就全部填充到temp
              temp[t] = arr[i];
              t += 1;
              i += 1;
          }
          while (j <= right) { // 右边的有序序列还有剩余的元素，就全部填充到temp
              temp[t] = arr[j];
              t += 1;
              j += 1;
          }
          // (三)
          // 将temp数组的元素拷贝到arr
          // 注意，并不是每次都拷贝所有
          t = 0;
          int tempLeft = left; //
          // 第一次合并 tempLeft = 0 , right = 1 // tempLeft = 2 right = 3 // tL=0 ri=3
          // 最后一次 tempLeft = 0 right = 7
          while (tempLeft <= right) {
              arr[tempLeft] = temp[t];
              t += 1;
              tempLeft += 1;
          }
     }
}

结果：

800000个数据，本人机器需要3s
排序前
排序前的时间是=2021-01-04 23:23:26
排序前的时间是=2021-01-04 23:23:29

---

（四）基数排序

（1）基数排序介绍
基数排序 (Radix Sort) 是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。基数排序的发明可以追溯到 1887 年赫尔曼·何乐礼在打孔卡片制表机 (Tabulation Machine)上的贡献

基数排序法会使用到桶 (Bucket)，顾名思义，通过将要比较的位（个位、十位、百位…），将要排序的元素分配至 0~9 个桶中，借以达到排序的作用，在某些时候，基数排序法的效率高于其它的比较性排序法

---

（2）基数排序基本思想
将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零

从最低位开始，依次进行一次排序

从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列

---

（3）基数排序动画

动画解释：

基数排序的方式可以采用 LSD (Least sgnificant digital) 或 MSD (Most sgnificant digital)

在本例中使用的是 LSD

首先创建编号 0 ， 1 ，2 ，3 ，4 ，5 ， 6 ，7 ，8 ，9 这 10 个桶

遍历整个数列，查看数字的个位数，按照先后顺序存放在对应编号的桶中

比如 321 个位数 为 1 ，存放在编号 1 桶中

数字 1 个位数 为 1 ，存放在编号 1 桶中，同时存放在 321 上面

遍历完整个数列的个位数，将数字存放在桶中后，按照编号顺序取出数字，先放入桶中的数字先取出

然后依次遍历整个数列的十位数，按照上述个位数的操作整理数列

依次遍历整个数列的百位数，按照上述个位数的操作整理数列

这样就完成了 基数排序

---

（4）基数排序代码
代码：（推导过程）

package com.lzacking.sort;
import java.util.Arrays;
public class RadixSort {

     public static void main(String[] args) {
          int arr[] = { 53, 3, 542, 748, 14, 214 };
          radixSort(arr);
          System.out.println("基数排序后 " + Arrays.toString(arr));
     }
     
     // 基数排序方法
     public static void radixSort(int[] arr) {
          // 定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
          // 说明
          // 1. 二维数组包含10个一维数组
          // 2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
          // 3. 名明确，基数排序是使用空间换时间的经典算法
          int[][] bucket = new int[10][arr.length];
          // 为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
          // 可以这里理解
          // 比如：bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数
          int[] bucketElementCounts = new int[10];
          // 第1轮(针对每个元素的个位进行排序处理)
          for (int j = 0; j < arr.length; j++) {
              // 取出每个元素的个位的值
              int digitOfElement = arr[j] / 1 % 10;
              // 放入到对应的桶中
              bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
              bucketElementCounts[digitOfElement]++;
          }
          // 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
          int index = 0;
          // 遍历每一桶，并将桶中是数据，放入到原数组
          for (int k = 0; k < bucketElementCounts.length; k++) {
              // 如果桶中，有数据，我们才放入到原数组
              if (bucketElementCounts[k] != 0) {
                   // 循环该桶即第k个桶(即第k个一维数组), 放入
                   for (int l = 0; l < bucketElementCounts[k]; l++) {
                        // 取出元素放入到arr
                        arr[index++] = bucket[k][l];
                   }
              }
              // 第l轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
              bucketElementCounts[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; // 748 / 10 => 74 % 10 => 4
              // 放入到对应的桶中
              bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
              bucketElementCounts[digitOfElement]++;
          }
          // 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
          index = 0;
          // 遍历每一桶，并将桶中是数据，放入到原数组
          for (int k = 0; k < bucketElementCounts.length; k++) {
              // 如果桶中，有数据，我们才放入到原数组
              if (bucketElementCounts[k] != 0) {
                   // 循环该桶即第k个桶(即第k个一维数组), 放入
                   for (int l = 0; l < bucketElementCounts[k]; l++) {
                        // 取出元素放入到arr
                        arr[index++] = bucket[k][l];
                   }
              }
              // 第2轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
              bucketElementCounts[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; // 748 / 100 => 7 % 10 = 7
              // 放入到对应的桶中
              bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
              bucketElementCounts[digitOfElement]++;
          }
          // 按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
          index = 0;
          // 遍历每一桶，并将桶中是数据，放入到原数组
          for (int k = 0; k < bucketElementCounts.length; k++) {
              // 如果桶中，有数据，我们才放入到原数组
              if (bucketElementCounts[k] != 0) {
                   // 循环该桶即第k个桶(即第k个一维数组), 放入
                   for (int l = 0; l < bucketElementCounts[k]; l++) {
                        // 取出元素放入到arr
                        arr[index++] = bucket[k][l];
                   }
              }
              // 第3轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
              bucketElementCounts[k] = 0;
          }
          System.out.println("第3轮，对个位的排序处理 arr =" + Arrays.toString(arr));
     }
}

结果：

第1轮，对个位的排序处理 arr =[542, 53, 3, 14, 214, 748]
第2轮，对个位的排序处理 arr =[3, 14, 214, 542, 748, 53]
第3轮，对个位的排序处理 arr =[3, 14, 53, 214, 542, 748]
基数排序后 [3, 14, 53, 214, 542, 748]

---

代码：（简化版）

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class RadixSort {
     public static void main(String[] args) {
          int arr[] = { 53, 3, 542, 748, 14, 214 };
          radixSort(arr);
          System.out.println("基数排序后 " + Arrays.toString(arr));
     }
     
     // 基数排序方法
     public static void radixSort(int[] arr) {
          // 根据前面的推导过程，我们可以得到最终的基数排序代码
          // 1. 得到数组中最大的数的位数
          int max = arr[0]; // 假设第一数就是最大数
          for (int i = 1; i < arr.length; i++) {
              if (arr[i] > max) {
                   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 < bucketElementCounts.length; k++) {
                   // 如果桶中，有数据，我们才放入到原数组
                   if (bucketElementCounts[k] != 0) {
                        // 循环该桶即第k个桶(即第k个一维数组), 放入
                        for (int l = 0; l < bucketElementCounts[k]; l++) {
                             // 取出元素放入到arr
                             arr[index++] = bucket[k][l];
                        }
                   }
                   // 第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
                   bucketElementCounts[k] = 0;
              }
              System.out.println("第"+(i+1)+"轮，对个位的排序处理 arr =" + Arrays.toString(arr));
          }
     }
}

结果：

第1轮，对个位的排序处理 arr =[542, 53, 3, 14, 214, 748]
第2轮，对个位的排序处理 arr =[3, 14, 214, 542, 748, 53]
第3轮，对个位的排序处理 arr =[3, 14, 53, 214, 542, 748]
基数排序后 [3, 14, 53, 214, 542, 748]

---

代码：（速度测试）

package com.lzacking.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class RadixSort {
     public static void main(String[] args) {
          // 80000000 * 11 * 4 / 1024 / 1024 / 1024 = 3.3G 当数据非常大的时候，会造成内存溢出
          int[] arr = new int[80000];
          for (int i = 0; i < 80000; i++) {
              arr[i] = (int) (Math.random() * 80000); // 生成一个[0, 80000) 数
          }
          System.out.println("排序前");
          Date data1 = new Date();
          SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
          String date1Str = simpleDateFormat.format(data1);
          System.out.println("排序前的时间是=" + date1Str);
          radixSort(arr);
          Date data2 = new Date();
          String date2Str = simpleDateFormat.format(data2);
          System.out.println("排序前的时间是=" + date2Str);
     }
     
     // 基数排序方法
     public static void radixSort(int[] arr) {
          // 根据前面的推导过程，我们可以得到最终的基数排序代码
          // 1. 得到数组中最大的数的位数
          int max = arr[0]; // 假设第一数就是最大数
          for (int i = 1; i < arr.length; i++) {
              if (arr[i] > max) {
                   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 < bucketElementCounts.length; k++) {
                   // 如果桶中，有数据，我们才放入到原数组
                   if (bucketElementCounts[k] != 0) {
                        // 循环该桶即第k个桶(即第k个一维数组), 放入
                        for (int l = 0; l < bucketElementCounts[k]; l++) {
                             // 取出元素放入到arr
                             arr[index++] = bucket[k][l];
                        }
                   }
                   // 第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
                   bucketElementCounts[k] = 0;
              }
          }
     }
}

结果：本人机器80000数据排序，需要1s

排序前
排序前的时间是=2021-01-05 23:34:37
排序前的时间是=2021-01-05 23:34:38