排序算法知识及编程练习总结

目录

一、背景知识介绍

二、主流排序算法与应用

（一）主流算法介绍

（二）在框架中的应用举例

三、相关排序算法练习

（一）冒泡排序（Bubble Sort）

扩展：基本优化思路展示

扩展：鸡尾酒排序

(二) 插入排序（Insertion Sort）

扩展：优化方案（二分插入排序+希尔排序+对小规模子序列使用插入排序+优化交换操作）

（三）选择排序（Selection Sort）

（四）快速排序（Quick Sort）

扩展：优化方法（基准值的选择和随机化）

扩展：非递归实现方式

（五）归并排序（Merge Sort）

扩展：优化思路分析

（六）堆排序（Heap Sort）

扩展：Top K 问题分析

求解思路罗列

推荐解法分析

最小 Top K代码展示

最大 Top K代码展示

扩展：使用堆排序思想实现优先级队列

（七）计数排序（Counting Sort）

扩展：数组中有大量重复元素，如何高效地进行排序？

扩展：给定一组学生成绩，如何按照成绩范围进行统计？

扩展：如何对字符串数组按照字母顺序进行排序？

扩展：如何对多个关键字进行排序？

相关扩展思路代码验证

（八）桶排序（Bucket Sort）

扩展：按照年龄对一组人员进行排序

扩展：对一组考试成绩进行排序

扩展：对一组具有相同前缀的字符串进行排序

（九）基数排序（Radix Sort）

扩展：对一组手机号码进行排序

扩展：对一组身份证号码进行排序

扩展：对一组IP地址进行排序

四、总结

干货分享，感谢您的阅读！祝你逢考必过！

一、背景知识介绍

排序算法是计算机科学中的一种基本算法，用于将一组元素按照特定的顺序进行排列。排序算法在计算机领域中应用广泛，包括数据库查询、数据分析、搜索引擎、图像处理、科学计算、大数据处理等众多领域。

排序算法的背景可以追溯到很早的计算机科学历史。随着计算机的发展和普及，对于对大量数据进行排序的需求逐渐增加，人们提出了许多不同的排序算法，以满足不同场景下的排序需求。排序算法的研究旨在提高排序的效率、减少排序的时间复杂度、节省排序的空间复杂度，从而更好地应对不同规模和类型的数据。

排序算法可以根据其执行方式和性能特点进行分类，例如比较排序和非比较排序、稳定排序和非稳定排序、内部排序和外部排序等。比较排序是指通过比较元素之间的大小关系来确定元素的排序顺序，而非比较排序是指通过其他方式来确定元素的排序顺序，例如基于元素的键值、计数、桶等。稳定排序是指在排序过程中相等元素的相对顺序保持不变，而非稳定排序则没有这种保证。内部排序是指在内存中直接对数据进行排序，而外部排序是指在外存中对数据进行排序。

不同的排序算法适用于不同的排序场景。例如，快速排序和归并排序在处理大规模数据时效果较好，而插入排序和冒泡排序在处理小规模数据时可能更为高效。选择排序和堆排序在对数据进行实时排序时可能更合适。计数排序和桶排序在处理具有特定分布特性的数据时可能更加高效。因此，选择合适的排序算法对于实际应用的性能和效率非常重要。

二、主流排序算法与应用

（一）主流算法介绍

以下只进行罗列一些基本的算法，展示如下：

  1. 快速排序（Quick Sort）：一种分治法的排序算法，通过选择一个基准元素将数组分为两个子数组，然后递归地对子数组进行排序。具有平均情况下较好的性能，时间复杂度为平均O(nlogn)，最坏情况下O(n^2)。
  2. 归并排序（Merge Sort）：一种基于分治法的排序算法，通过将数组分为两个子数组，递归地对子数组进行排序，然后合并两个已排序的子数组。具有稳定的排序性质，时间复杂度为O(nlogn)。
  3. 插入排序（Insertion Sort）：一种简单的排序算法，通过将未排序的元素逐个插入已排序的子数组中，从而将整个数组排序。适合处理小规模数据，时间复杂度为平均O(n^2)，但在某些情况下可以达到O(n)。
  4. 选择排序（Selection Sort）：一种简单的排序算法，通过选择未排序部分的最小或最大元素，将其与已排序部分的末尾交换，从而将整个数组排序。时间复杂度为平均O(n^2)。
  5. 堆排序（Heap Sort）：一种基于二叉堆的排序算法，通过构建最大堆或最小堆，将堆顶元素与末尾元素交换并调整堆，从而将整个数组排序。时间复杂度为O(nlogn)。
  6. 冒泡排序（Bubble Sort）：一种简单的排序算法，通过不断交换相邻的元素，将较大或较小的元素逐渐“冒泡”到数组的末尾，从而将整个数组排序。时间复杂度为平均O(n^2)。
  7. 计数排序（Counting Sort）：一种非比较排序算法，通过统计每个元素出现的次数，然后根据统计结果将元素放置到正确的位置，从而将整个数组排序。适合处理具有特定分布特性的数据，时间复杂度为O(n+k)，其中k为数据范围。
  8. 桶排序（Bucket Sort）：一种非比较排序算法，通过将元素分散到不同的桶中，然后对每个桶中的元素进行排序，最后合并桶中的元素，从而将整个数组排序。适合处理具有特定分布特性的数据，时间复杂度为平均O(n+k)，其中k为桶的个数。

（二）在框架中的应用举例

实际应用较多，以下展示一些基本的示例：

  1. Java 标准库：Java 提供了丰富的排序算法实现，如 Arrays.sort() 和 Collections.sort() 方法，可以用于对数组和集合进行排序操作。
  2. Python 标准库：Python 也提供了多种排序算法的实现，如 sorted() 和 list.sort() 函数，可以用于对列表进行排序。
  3. JavaScript：JavaScript 语言本身提供了 Array.prototype.sort() 方法，用于对数组进行排序操作，可以根据指定的排序规则进行排序。
  4. .NET Framework：.NET Framework 中的 System.Array 类和 System.Collections.Generic.List 类都提供了排序算法的实现，可用于对数组和集合进行排序操作。
  5. 数据库：数据库系统中通常也内置了排序功能，可以通过 SQL 查询语句中的 ORDER BY 子句进行排序操作，例如在 MySQL、Oracle、SQL Server 等数据库中都可以使用 ORDER BY 子句对查询结果进行排序。
  6. Web 开发框架：在许多 Web 开发框架中，排序算法也被广泛应用于对前端展示的数据进行排序，例如在前端框架如 React、Angular、Vue 等中，可以使用内置的排序函数或自定义排序算法对前端数据进行排序展示。

三、相关排序算法练习

（一）冒泡排序（Bubble Sort）

基本知识介绍

冒泡排序（Bubble Sort）是一种简单的排序算法，它通过不断地交换相邻两个元素的位置，把最大的元素逐渐“冒泡”到数组的最后面，从而实现排序。

bubbleSort.gif

具体来说，冒泡排序的基本思想是：从数组的第一个元素开始，依次比较相邻两个元素的大小，如果它们的顺序不正确，就交换它们的位置，然后继续比较下一组相邻元素，直到数组的末尾。这个过程可以理解为每一轮都将一个最大的元素“冒泡”到了数组的最后面。

冒泡排序的时间复杂度为O(n^2)，其中n是数组的长度。虽然它的效率不如其他高级排序算法，但是它简单易懂，实现也很容易，可以用来对小规模的数据进行排序。

具体代码示例

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. /**
  4.  * @author yanfengzhang
  5.  * @description 冒泡排序（Bubble Sort）
  6.  * 通过不断地交换相邻两个元素的位置，把最大的元素逐渐“冒泡”到数组的最后面，从而实现排序.
  7.  * @date 2023/4/15  22:15
  8.  */
  9. public class BubbleSort {
  10.     public static void bubbleSort(int[] array) {
  11.         /*获取数组长度*/
  12.         int n = array.length;
  13.         /*外层循环控制排序轮数*/
  14.         for (int i = 0; i < n; i++) {
  15.             /*内层循环控制每轮比较的次数*/
  16.             for (int j = 0; j < n - i - 1; j++) {
  17.                 /*如果顺序不正确就交换相邻两个元素的位置*/
  18.                 if (array[j] > array[j + 1]) {
  19.                     int temp = array[j];
  20.                     array[j] = array[j + 1];
  21.                     array[j + 1] = temp;
  22.                 }
  23.             }
  24.         }
  25.     }
  26.  
  27.     public static void main(String[] args) {
  28.         /*创建一个待排序的数组*/
  29.         int[] array = {5, 3, 8, 6, 4};
  30.         /*对数组进行排序*/
  31.         bubbleSort(array);
  32.         /*输出排序后的结果*/
  33.         for (int i = 0; i < array.length; i++) {
  34.             System.out.print(array[i] + " ");
  35.         }
  36.     }
  37. }

扩展：基本优化思路展示

对于冒泡排序，有一些常见的优化思路，可以提高它的效率，例如：

  1. 如果在某一轮循环中没有任何元素交换位置，说明数组已经排好序，可以直接退出循环，不必再进行后续的比较。
  2. 对于每一轮循环，如果最后一个发生交换的位置为 pos，说明从 pos+1 到数组末尾的元素已经有序了，可以直接把这部分元素排除在下一轮的比较之外。
  1.  public static void bubbleSort(int[] array) {
  2.         int n = array.length;
  3.         /*记录最后一次交换的位置*/
  4.         int lastSwappedIndex = n - 1;
  5.         for (int i = 0; i < n; i++) {
  6.             /*标记本轮循环是否有交换发生*/
  7.             boolean swapped = false;
  8.             for (int j = 0; j < lastSwappedIndex; j++) {
  9.                 if (array[j] > array[j + 1]) {
  10.                     int temp = array[j];
  11.                     array[j] = array[j + 1];
  12.                     array[j + 1] = temp;
  13.                     swapped = true;
  14.                 }
  15.             }
  16.             /*如果本轮循环没有交换发生，说明已经排好序*/
  17.             if (!swapped) {
  18.                 break;
  19.             }
  20.             /*更新最后一次交换的位置*/
  21.             lastSwappedIndex--;
  22.         }
  23.     }

扩展：鸡尾酒排序

鸡尾酒排序（Cocktail Sort），也称为双向冒泡排序（Bidirectional Bubble Sort）、定向冒泡排序（Cocktail Shaker Sort）等，是一种改进的冒泡排序算法。它与冒泡排序的不同之处在于，鸡尾酒排序的每一轮排序都是双向的，即从头到尾进行一次冒泡排序，然后再从尾到头进行一次冒泡排序，以此类推，直到排序完成。

在排序过程中，鸡尾酒排序可以有效地避免冒泡排序的一些缺点，比如在数组末尾有大量无序的元素时，冒泡排序的排序效率会变得很低。而鸡尾酒排序通过双向排序，可以将大的元素快速地移动到数组末尾，并将小的元素快速地移动到数组开头，从而提高了排序的效率。

因此，可以说鸡尾酒排序是冒泡排序的一种优化算法，它可以更快地完成排序任务，并且在某些特定情况下比冒泡排序更加适用。具体步骤如下：

  1. 从左向右进行一次冒泡排序，将最大的元素放到数组的末尾。
  2. 从右向左进行一次冒泡排序，将最小的元素放到数组的开头。
  3. 重复步骤1和2，直到整个数组有序。

这里需要注意的是，每次双向冒泡排序都需要记录当前排序的边界，即已经排好序的部分的位置。在第一次从左向右排序时，最后一个交换元素的位置就是当前的边界。在第一次从右向左排序时，第一个交换元素的位置就是当前的边界。以后每次排序时，边界会根据上一次排序的结果进行更新。

需要注意的是，当数组已经排好序时，鸡尾酒排序仍然会执行完所有的双向冒泡排序，因此最坏情况下的时间复杂度仍然是 O(n^2)。但在一般情况下，鸡尾酒排序的效率要比冒泡排序高。

  1.     public static void cocktailSort(int[] arr) {
  2.         /*标志位，记录是否进行过交换*/
  3.         boolean swapped = true;
  4.         /*从左向右排序的起始位置*/
  5.         int start = 0;
  6.         /*从右向左排序的起始位置*/
  7.         int end = arr.length - 1;
  8.  
  9.         /*只要还有元素需要排序就继续循环*/
  10.         while (swapped) {
  11.             swapped = false;
  12.  
  13.             /*从左向右进行一次冒泡排序，将最大的元素放到数组的末尾*/
  14.             for (int i = start; i < end; i++) {
  15.                 if (arr[i] > arr[i + 1]) {
  16.                     /*交换两个元素的位置*/
  17.                     swap(arr, i, i + 1);
  18.                     /*标记已经进行过交换*/
  19.                     swapped = true;
  20.                 }
  21.             }
  22.             /*如果没有进行过交换，则说明数组已经有序，直接退出循环*/
  23.             if (!swapped) {
  24.                 break;
  25.             }
  26.  
  27.             swapped = false;
  28.             /*更新从右向左排序的起始位置*/
  29.             end--;
  30.  
  31.             /*从右向左进行一次冒泡排序，将最小的元素放到数组的开头*/
  32.             for (int i = end - 1; i >= start; i--) {
  33.                 if (arr[i] > arr[i + 1]) {
  34.                     swap(arr, i, i + 1);
  35.                     swapped = true;
  36.                 }
  37.             }
  38.             /*更新从左向右排序的起始位置*/
  39.             start++;
  40.         }
  41.     }
  42.  
  43.     /*交换数组中两个元素的位置*/
  44.     private static void swap(int[] arr, int i, int j) {
  45.         int temp = arr[i];
  46.         arr[i] = arr[j];
  47.         arr[j] = temp;
  48.     }

(二) 插入排序（Insertion Sort）

 基本知识介绍

插入排序是一种简单直观的排序算法，其基本思想是将一个记录插入到已经排好序的有序序列中，直到整个序列有序为止。

其具体步骤如下：

  1. 将数组的第一个元素视为有序序列，第二个元素到最后一个元素视为待排序序列。
  2. 从待排序序列中取出一个元素，将其插入到已排序序列中的适当位置，使得插入后的序列仍然有序。
  3. 重复步骤2，直到待排序序列为空。

在插入排序中，我们通常使用交换或移动元素的方法来实现元素的插入操作。如果使用交换元素的方法，则时间复杂度为O(n^2)；如果使用移动元素的方法，则时间复杂度为 O(n)。在实际应用中，我们通常采用后者来实现插入排序。插入排序虽然时间复杂度较高，但由于其代码实现简单、稳定性好等优点，在小规模数据排序时仍然被广泛使用。

具体代码展示

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. /**
  4.  * @author yanfengzhang
  5.  * @description 插入排序（Insertion Sort）
  6.  * 基本思想是将一个记录插入到已经排好序的有序序列中，直到整个序列有序为止。
  7.  * @date 2023/4/15  22:40
  8.  */
  9. public class InsertionSort {
  10.     public static void insertionSort(int[] arr) {
  11.         int n = arr.length;
  12.         /*i从1开始，因为第一个元素已经是有序的*/
  13.         for (int i = 1; i < n; i++) {
  14.             /*待插入的元素，当前待排序元素*/
  15.             int key = arr[i];
  16.             /*从已排序序列中的最后一个元素开始比较*/
  17.             int j = i - 1;
  18.  
  19.             /*将已排序序列中大于待插入元素的元素依次后移*/
  20.             while (j >= 0 && arr[j] > key) {
  21.                 arr[j + 1] = arr[j];
  22.                 j--;
  23.             }
  24.             /*将待插入元素插入到已排序序列中的合适位置*/
  25.             arr[j + 1] = key;
  26.         }
  27.     }
  28.  
  29.     public static void main(String[] args) {
  30.         /*创建一个待排序的数组*/
  31.         int[] array = {5, 3, 8, 6, 4};
  32.         /*对数组进行排序*/
  33.         insertionSort(array);
  34.         /*输出排序后的结果*/
  35.         for (int i = 0; i < array.length; i++) {
  36.             System.out.print(array[i] + " ");
  37.         }
  38.     }
  39.  
  40. }

扩展：优化方案（二分插入排序+希尔排序+对小规模子序列使用插入排序+优化交换操作）

插入排序虽然简单易懂，但它的时间复杂度为 O(n^2)，对于大规模数据的排序效率较低。在实际应用中，我们可以对插入排序进行一些优化，从而提高其效率。以下是一些常用的插入排序优化方法：

  1. 二分插入排序：在已排序序列中采用二分查找的方式，找到待插入元素的插入位置，从而减少比较次数。时间复杂度为 O(n \log n)，略优于插入排序的 O(n^2)。
  2. 希尔排序：希尔排序是插入排序的一种改进版，它通过将待排序序列分为若干子序列，对每个子序列进行插入排序，从而使得整个序列逐渐有序。时间复杂度为 O(n \log n)$或 O(n^{\frac{4}{3}})，具体取决于子序列的划分方法。
  3. 对小规模子序列使用插入排序：对于小规模的子序列，插入排序的效率往往比快速排序等高级排序算法更高。因此，我们可以在快速排序等高级排序算法中，对小规模子序列采用插入排序来进行排序，从而提高整个算法的效率。
  4. 优化交换操作：在插入排序中，交换元素的次数和比较元素的次数都会对效率产生影响。为了减少交换操作的次数，我们可以在每次比较时，将待插入元素的值存储在一个临时变量中，等待所有比它大的元素都后移后，再将它插入到应该插入的位置上。这样一来，交换操作就只需要进行一次，而不是每次比较都进行一次。

以上是常用的几种插入排序的优化方法，通过对这些优化方法的组合使用，我们可以使得插入排序在实际应用中表现更加出色。

  1.     public static void insertionSortOpti(int[] arr) {
  2.         int n = arr.length;
  3.         /*优化1：二分插入排序*/
  4.         for (int i = 1; i < n; i++) {
  5.             int left = 0, right = i - 1;
  6.             int target = arr[i];
  7.             while (left <= right) {
  8.                 int mid = left + (right - left) / 2;
  9.                 if (arr[mid] > target) {
  10.                     right = mid - 1;
  11.                 } else {
  12.                     left = mid + 1;
  13.                 }
  14.             }
  15.             for (int j = i; j > left; j--) {
  16.                 arr[j] = arr[j - 1];
  17.             }
  18.             arr[left] = target;
  19.         }
  20.  
  21.         /*优化2：希尔排序*/
  22.         for (int gap = n / 2; gap > 0; gap /= 2) {
  23.             for (int i = gap; i < n; i++) {
  24.                 int j = i;
  25.                 int temp = arr[j];
  26.                 while (j - gap >= 0 && arr[j - gap] > temp) {
  27.                     arr[j] = arr[j - gap];
  28.                     j -= gap;
  29.                 }
  30.                 arr[j] = temp;
  31.             }
  32.         }
  33.  
  34.         /*优化3：对小规模子序列使用插入排序*/
  35.         for (int i = 1; i < n; i++) {
  36.             for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
  37.                 swap(arr, j, j - 1);
  38.             }
  39.         }
  40.  
  41.         /*优化4：优化交换操作*/
  42.         for (int i = 1; i < n; i++) {
  43.             int temp = arr[i];
  44.             int j;
  45.             for (j = i; j > 0 && arr[j - 1] > temp; j--) {
  46.                 arr[j] = arr[j - 1];
  47.             }
  48.             arr[j] = temp;
  49.         }
  50.     }
  51.  
  52.     private static void swap(int[] arr, int i, int j) {
  53.         int temp = arr[i];
  54.         arr[i] = arr[j];
  55.         arr[j] = temp;
  56.     }

（三）选择排序（Selection Sort）

 基本知识介绍

选择排序的基本思路是：每次从待排序的序列中找到最小（或最大）的元素，放到已排序序列的末尾。具体实现时，我们通过两层循环来找到最小元素的下标，然后将该元素与序列的起始位置进行交换，从而将该元素放到已排序序列的末尾。通过不断重复这个过程，直到整个序列都排好序为止。

选择排序的时间复杂度是 O(n^2)，比较稳定，适用于对于数据规模较小的排序任务。它的优点在于不需要额外的存储空间，但是它的缺点是效率不够高，尤其是在数据规模较大时。因此，通常在实际应用中，选择排序并不是首选的排序算法。

选择排序的主要特点是交换次数比较少，但是比较次数较多，因此可以通过减少比较次数来优化它的性能。例如，可以通过记录每次查找到的最小元素的下标，而不是直接交换元素来减少交换次数。另外，也可以通过增加一个有序区域来减少比较次数，具体的实现可以参考改进后的选择排序算法。

具体代码展示

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. /**
  4.  * @author yanfengzhang
  5.  * @description 选择排序算法
  6.  * 选择排序的基本思路是：每次从待排序的序列中找到最小（或最大）的元素，放到已排序序列的末尾。
  7.  * 具体实现时，我们通过两层循环来找到最小元素的下标，然后将该元素与序列的起始位置进行交换，
  8.  * 从而将该元素放到已排序序列的末尾。通过不断重复这个过程，直到整个序列都排好序为止。
  9.  * @date 2023/4/15  23:10
  10.  */
  11. public class SelectionSort {
  12.     /**
  13.      * 选择排序算法
  14.      *
  15.      * @param arr 待排序的数组
  16.      */
  17.     public static void selectionSort(int[] arr) {
  18.         int n = arr.length;
  19.         /*依次选择未排序区间的最小值并将其放到已排序区间的末尾*/
  20.         for (int i = 0; i < n - 1; i++) {
  21.             /*记录未排序区间的最小值下标*/
  22.             int minIndex = i;
  23.             /*在未排序区间中寻找最小值*/
  24.             for (int j = i + 1; j < n; j++) {
  25.                 if (arr[j] < arr[minIndex]) {
  26.                     minIndex = j;
  27.                 }
  28.             }
  29.             /*将未排序区间的最小值与已排序区间的末尾交换位置*/
  30.             if (minIndex != i) {
  31.                 swap(arr, i, minIndex);
  32.             }
  33.         }
  34.     }
  35.  
  36.     /**
  37.      * 交换数组中的两个元素
  38.      *
  39.      * @param arr 数组
  40.      * @param i   第一个元素的下标
  41.      * @param j   第二个元素的下标
  42.      */
  43.     private static void swap(int[] arr, int i, int j) {
  44.         int temp = arr[i];
  45.         arr[i] = arr[j];
  46.         arr[j] = temp;
  47.     }
  48.  
  49.     public static void main(String[] args) {
  50.         /*创建一个待排序的数组*/
  51.         int[] array = {5, 3, 8, 6, 4};
  52.         /*对数组进行排序*/
  53.         selectionSort(array);
  54.         /*输出排序后的结果*/
  55.         for (int i = 0; i < array.length; i++) {
  56.             System.out.print(array[i] + " ");
  57.         }
  58.     }
  59. }

（四）快速排序（Quick Sort）

基本知识介绍

快速排序（Quick Sort）是一种基于分治思想的高效排序算法，由C. A. R. Hoare在1960年提出。它的基本思路是选择一个元素作为基准值（Pivot），将待排序序列分割成两个子序列：小于等于基准值的元素序列和大于基准值的元素序列，然后对这两个子序列递归地进行快速排序。

 具体来说，快速排序的实现步骤如下：

  1. 选取基准值：从待排序序列中任选一个元素作为基准值。
  2. 分割操作：通过一趟排序将待排序序列分割成两个部分，其中一部分的所有元素均小于等于基准值，另一部分的所有元素均大于基准值，并把基准值放在它们之间。
  3. 递归地对子序列进行快速排序：递归地对小于等于基准值的子序列和大于基准值的子序列进行快速排序。
  4. 合并操作：已经有序的子序列无需合并。

快速排序算法的时间复杂度为 O(n\log n)，在处理大规模数据时效率较高。但在极端情况下，比如待排序序列已经有序或基本有序时，快速排序的时间复杂度会退化到 O(n^2)，因此需要针对这种情况进行优化。

具体代码展示

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. /**
  4.  * @author yanfengzhang
  5.  * @description 快速排序（Quick Sort）
  6.  * 基本思路是选择一个元素作为基准值（Pivot），将待排序序列分割成两个子序列：
  7.  * 小于等于基准值的元素序列和大于基准值的元素序列，然后对这两个子序列递归地进行快速排序。
  8.  * @date 2023/4/15  23:28
  9.  */
  10. public class QuickSort {
  11.     /**
  12.      * 快速排序算法
  13.      *
  14.      * @param arr   待排序的数组
  15.      * @param left  待排序序列的左端点
  16.      * @param right 待排序序列的右端点
  17.      */
  18.     public static void quickSort(int[] arr, int left, int right) {
  19.         /*递归结束条件：子序列的长度为1或0*/
  20.         if (left >= right) {
  21.             return;
  22.         }
  23.         /*进行分割操作*/
  24.         int pivotIndex = partition(arr, left, right);
  25.         /*递归地对小于等于基准值的子序列进行快速排序*/
  26.         quickSort(arr, left, pivotIndex - 1);
  27.         /*递归地对大于基准值的子序列进行快速排序*/
  28.         quickSort(arr, pivotIndex + 1, right);
  29.     }
  30.  
  31.     /**
  32.      * 分割操作
  33.      *
  34.      * @param arr   待分割的数组
  35.      * @param left  待分割序列的左端点
  36.      * @param right 待分割序列的右端点
  37.      * @return 分割元素的下标
  38.      */
  39.     private static int partition(int[] arr, int left, int right) {
  40.         /*选取基准值*/
  41.         int pivot = arr[left];
  42.         int i = left, j = right;
  43.         /*当 i 和 j 相遇时退出循环*/
  44.         while (i < j) {
  45.             /*从右往左找到第一个小于基准值的元素*/
  46.             while (i < j && arr[j] >= pivot) {
  47.                 j--;
  48.             }
  49.             /*将该元素放到基准值的左边*/
  50.             arr[i] = arr[j];
  51.             /*从左往右找到第一个大于基准值的元素*/
  52.             while (i < j && arr[i] <= pivot) {
  53.                 i++;
  54.             }
  55.             /*将该元素放到基准值的右边*/
  56.             arr[j] = arr[i];
  57.         }
  58.         /*将基准值放到最终位置*/
  59.         arr[i] = pivot;
  60.         /*返回基准值的下标*/
  61.         return i;
  62.     }
  63.  
  64.     public static void main(String[] args) {
  65.         /*创建一个待排序的数组*/
  66.         int[] array = {5, 3, 8, 6, 4};
  67.         /*对数组进行排序*/
  68.         quickSort(array, 0, 4);
  69.         /*输出排序后的结果*/
  70.         for (int i = 0; i < array.length; i++) {
  71.             System.out.print(array[i] + " ");
  72.         }
  73.     }
  74. }

扩展：优化方法（基准值的选择和随机化）

快速排序算法的优化主要集中在两个方面：基准值的选择和随机化。

一般来说，选择合适的基准值可以有效减少快速排序的时间复杂度。如果选择的基准值不够随机或者不够优秀，快速排序的时间复杂度可能会退化到 O(n^2)。以下是一些常见的基准值选择方法：

  • 选择第一个元素或最后一个元素作为基准值。这种方法非常简单，但是在特定情况下容易退化。
  • 选择中间元素作为基准值。这种方法比较合理，但是在序列有序的情况下仍然会退化。
  • 选择随机元素作为基准值。这种方法可以避免序列已经有序的情况，但是需要额外的随机数生成操作。

另一个常见的优化方法是随机化。在快速排序过程中，如果每次选择的基准值都是最小或最大的元素，算法的时间复杂度将达到 O(n^2)。为了避免这种情况，可以随机打乱序列，使得每个元素被选为基准值的概率相等，从而保证算法的期望时间复杂度为 O(n\log n)。

以下是使用随机化和三数取中法的优化版本的Java代码实现：

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.Random;
  4.  
  5. /**
  6.  * @author yanfengzhang
  7.  * @description 快速排序算法（优化版）
  8.  * @date 2023/4/15  23:34
  9.  */
  10. public class QuickSortOpti {
  11.     /**
  12.      * 快速排序算法（优化版）
  13.      *
  14.      * @param arr   待排序的数组
  15.      * @param left  待排序序列的左端点
  16.      * @param right 待排序序列的右端点
  17.      */
  18.     public static void quickSort(int[] arr, int left, int right) {
  19.         /*递归结束条件：子序列的长度为1或0*/
  20.         if (left >= right) {
  21.             return;
  22.         }
  23.         /*选择基准值并将其交换到序列的左端点*/
  24.         int pivotIndex = left + new Random().nextInt(right - left + 1);
  25.         swap(arr, left, pivotIndex);
  26.         /*使用三数取中法选择合适的基准值*/
  27.         int pivot = medianOfThree(arr, left, right);
  28.         /*进行分割操作*/
  29.         pivotIndex = partition(arr, left, right, pivot);
  30.         /*递归地对小于等于基准值的子序列进行快速排序*/
  31.         quickSort(arr, left, pivotIndex - 1);
  32.         /*递归地对大于基准值的子序列进行快速排序*/
  33.         quickSort(arr, pivotIndex + 1, right);
  34.     }
  35.  
  36.     /**
  37.      * 交换数组中两个位置的元素
  38.      *
  39.      * @param arr 待交换元素所在的数组
  40.      * @param i   第一个元素的下标
  41.      * @param j   第二个元素的下标
  42.      */
  43.     private static void swap(int[] arr, int i, int j) {
  44.         int temp = arr[i];
  45.         arr[i] = arr[j];
  46.         arr[j] = temp;
  47.     }
  48.  
  49.     /**
  50.      * 三数取中法选择基准值
  51.      *
  52.      * @param arr   待选取的数组
  53.      * @param left  待选取数组的左端点
  54.      * @param right 待选取数组的右端点
  55.      * @return 选取的基准值
  56.      */
  57.     private static int medianOfThree(int[] arr, int left, int right) {
  58.         int mid = (left + right) / 2;
  59.         if (arr[left] > arr[mid]) {
  60.             swap(arr, left, mid);
  61.         }
  62.         if (arr[mid] > arr[right]) {
  63.             swap(arr, mid, right);
  64.         }
  65.         if (arr[left] > arr[mid]) {
  66.             swap(arr, left, mid);
  67.         }
  68.         return arr[mid];
  69.     }
  70.  
  71.     /**
  72.      * 将待排序序列分割成两个子序列
  73.      *
  74.      * @param arr   待分割序列
  75.      * @param left  待分割序列的左端点
  76.      * @param right 待分割序列的右端点
  77.      * @param pivot 基准值
  78.      * @return 基准值的最终位置
  79.      */
  80.     private static int partition(int[] arr, int left, int right, int pivot) {
  81.         int i = left + 1, j = right;
  82.         while (true) {
  83.             /*找到第一个大于基准值的元素*/
  84.             while (i < right && arr[i] <= pivot) {
  85.                 i++;
  86.             }
  87.             /*找到第一个小于基准值的元素*/
  88.             while (j > left && arr[j] >= pivot) {
  89.                 j--;
  90.             }
  91.             /*循环结束条件*/
  92.             if (i >= j) {
  93.                 break;
  94.             }
  95.             /*交换左右两个元素*/
  96.             swap(arr, i, j);
  97.             i++;
  98.             j--;
  99.         }
  100.         /*将基准值交换到正确的位置*/
  101.         swap(arr, left, j);
  102.         return j;
  103.     }
  104.  
  105.     public static void main(String[] args) {
  106.         /*创建一个待排序的数组*/
  107.         int[] array = {5, 3, 8, 6, 4};
  108.         /*对数组进行排序*/
  109.         quickSort(array, 0, 4);
  110.         /*输出排序后的结果*/
  111.         for (int i = 0; i < array.length; i++) {
  112.             System.out.print(array[i] + " ");
  113.         }
  114.     }
  115.  
  116. }

扩展：非递归实现方式

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.Random;
  4. import java.util.Stack;
  5.  
  6. /**
  7.  * @author yanfengzhang
  8.  * @description 迭代快速排序
  9.  * @date 2023/4/15  23:37
  10.  */
  11. public class IterativeQuickSort {
  12.     /**
  13.      * 迭代快速排序
  14.      *
  15.      * @param arr   待排序的数组
  16.      * @param left  待排序序列的左端点
  17.      * @param right 待排序序列的右端点
  18.      */
  19.     public static void iterativeQuickSort(int[] arr, int left, int right) {
  20.         Stack stack = new Stack<>();
  21.         stack.push(left);
  22.         stack.push(right);
  23.         while (!stack.isEmpty()) {
  24.             int r = stack.pop();
  25.             int l = stack.pop();
  26.             if (l >= r) {
  27.                 continue;
  28.             }
  29.             int pivotIndex = partition(arr, l, r);
  30.             stack.push(l);
  31.             stack.push(pivotIndex - 1);
  32.             stack.push(pivotIndex + 1);
  33.             stack.push(r);
  34.         }
  35.     }
  36.  
  37.     /**
  38.      * 分割操作
  39.      *
  40.      * @param arr   待分割的数组
  41.      * @param left  待分割序列的左端点
  42.      * @param right 待分割序列的右端点
  43.      * @return 基准值的下标
  44.      */
  45.     private static int partition(int[] arr, int left, int right) {
  46.         // 选择基准值并将其交换到序列的左端点*/
  47.         int pivotIndex = left + new Random().nextInt(right - left + 1);
  48.         swap(arr, left, pivotIndex);
  49.         int pivot = arr[left];
  50.         int i = left + 1;
  51.         int j = right;
  52.         while (i <= j) {
  53.             while (i <= j && arr[i] <= pivot) {
  54.                 i++;
  55.             }
  56.             while (i <= j && arr[j] > pivot) {
  57.                 j--;
  58.             }
  59.             if (i < j) {
  60.                 swap(arr, i, j);
  61.             }
  62.         }
  63.         swap(arr, left, j);
  64.         return j;
  65.     }
  66.  
  67.     /**
  68.      * 交换数组中两个位置的元素
  69.      *
  70.      * @param arr 待交换元素所在的数组
  71.      * @param i   第一个元素的下标
  72.      * @param j   第二个元素的下标
  73.      */
  74.     private static void swap(int[] arr, int i, int j) {
  75.         int temp = arr[i];
  76.         arr[i] = arr[j];
  77.         arr[j] = temp;
  78.     }
  79.  
  80.     public static void main(String[] args) {
  81.         /*创建一个待排序的数组*/
  82.         int[] array = {5, 3, 8, 6, 4};
  83.         /*对数组进行排序*/
  84.         iterativeQuickSort(array, 0, 4);
  85.         /*输出排序后的结果*/
  86.         for (int i = 0; i < array.length; i++) {
  87.             System.out.print(array[i] + " ");
  88.         }
  89.     }
  90.  
  91. }

（五）归并排序（Merge Sort）

基本知识介绍

归并排序是一种经典的基于比较的排序算法，它采用分治的思想来进行排序，其基本思路可以概括为以下三个步骤：

  1. 分解：将待排序的n个元素分成各含n/2个元素的子序列，递归地将子序列进行归并排序，直到子序列中只剩下一个元素。
  2. 合并：将两个已排好序的子序列合并成一个有序序列，即将两个有序序列不断地按照大小顺序取出元素，直到其中一个序列的元素全部取完，然后将剩余的序列中的元素直接添加到有序序列的末尾。
  3. 输出：当子序列的长度达到n时，整个序列也被排序完成。

归并排序的时间复杂度为O(nlogn)，空间复杂度为O(n)，是一种稳定的排序算法。

具体实现中，可以采用递归或迭代两种方式实现归并排序，其中迭代实现的归并排序常被称为“自底向上的归并排序”。

具体代码展示

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. /**
  4.  * @author yanfengzhang
  5.  * @description 归并排序算法
  6.  * 采用分治的思想来进行排序，其基本思路可以概括为以下三个步骤：
  7.  * 分解：将待排序的n个元素分成各含n/2个元素的子序列，递归地将子序列进行归并排序，直到子序列中只剩下一个元素。
  8.  * 合并：将两个已排好序的子序列合并成一个有序序列，即将两个有序序列不断地按照大小顺序取出元素，直到其中一个序列的元素全部取完，然后将剩余的序列中的元素直接添加到有序序列的末尾。
  9.  * 输出：当子序列的长度达到n时，整个序列也被排序完成。
  10.  * @date 2023/4/15  23:50
  11.  */
  12. public class MergeSort {
  13.     /**
  14.      * 归并排序算法
  15.      *
  16.      * @param arr   待排序的数组
  17.      * @param left  待排序序列的左端点
  18.      * @param right 待排序序列的右端点
  19.      */
  20.     public static void mergeSort(int[] arr, int left, int right) {
  21.         /*递归结束条件：子序列的长度为1或0*/
  22.         if (left >= right) {
  23.             return;
  24.         }
  25.         /*计算中间位置*/
  26.         int mid = left + (right - left) / 2;
  27.         /*对左半部分进行归并排序*/
  28.         mergeSort(arr, left, mid); 
  29.         /*对右半部分进行归并排序*/
  30.         mergeSort(arr, mid + 1, right); 
  31.         /*合并左右两个有序序列*/
  32.         merge(arr, left, mid, right);
  33.     }
  34.  
  35.     /**
  36.      * 将两个有序数组合并成一个有序数组
  37.      *
  38.      * @param arr   待合并的数组
  39.      * @param left  左边有序数组的起始下标
  40.      * @param mid   中间位置下标
  41.      * @param right 右边有序数组的结束下标
  42.      */
  43.     private static void merge(int[] arr, int left, int mid, int right) {
  44.         /*用于存放合并后的有序序列*/
  45.         int[] temp = new int[right - left + 1];
  46.         /*i和j分别指向左右两个有序数组的起始下标，k指向临时数组的起始下标*/
  47.         int i = left, j = mid + 1, k = 0;
  48.         while (i <= mid && j <= right) {
  49.             if (arr[i] <= arr[j]) {
  50.                 temp[k++] = arr[i++];
  51.             } else {
  52.                 temp[k++] = arr[j++];
  53.             }
  54.         }
  55.         while (i <= mid) {
  56.             temp[k++] = arr[i++];
  57.         }
  58.         while (j <= right) {
  59.             temp[k++] = arr[j++];
  60.         }
  61.         /*将临时数组中的元素复制回原数组*/
  62.         System.arraycopy(temp, 0, arr, left, temp.length);
  63.     }
  64.  
  65.     public static void main(String[] args) {
  66.         /*创建一个待排序的数组*/
  67.         int[] array = {5, 3, 8, 6, 4};
  68.         /*对数组进行排序*/
  69.         mergeSort(array, 0, 4);
  70.         /*输出排序后的结果*/
  71.         for (int i = 0; i < array.length; i++) {
  72.             System.out.print(array[i] + " ");
  73.         }
  74.     }
  75. }

扩展：优化思路分析

归并排序已经是一个时间复杂度为 O(nlogn) 的高效排序算法了，不过还是有一些优化思路可以提高其效率，主要包括以下几点：

  1. 对小规模子数组使用插入排序：当待排序的子数组长度比较小的时候，使用插入排序会比归并排序更加高效。一般来说，当子数组长度小于 15 左右时，使用插入排序效果最好。
  2. 对已经有序的子数组进行合并：当左右两个子数组都已经有序时，可以直接将它们合并而不需要再进行排序操作。这样可以节省一定的时间复杂度。
  3. 避免重复地创建辅助数组：在递归调用归并排序的过程中，会多次创建新的辅助数组。为了避免这种情况，可以在程序初始化的时候就创建一个足够大的辅助数组，然后在每次递归调用时都传入该数组的引用即可。
  4. 自底向上地进行归并排序：在对一个大数组进行排序时，归并排序需要递归调用很多次，这会带来较大的函数调用和栈空间的消耗。为了避免这种情况，可以使用自底向上的归并排序，从小的子数组开始逐渐合并到大的数组。

需要注意的是，虽然归并排序的时间复杂度已经非常高效，但是其空间复杂度仍然比较高，需要使用辅助数组来进行排序，因此在排序大规模数据时需要注意空间限制。

建议：当数据量较小时，插入排序的性能优于归并排序，因此可以在递归过程中判断子序列的长度，当其小于一定值时采用插入排序来优化归并排序的性能。

代码展示如下（只展示了mergeSort方法的修改部分）：

  1.     /**
  2.      * 归并排序算法（优化版）
  3.      *
  4.      * @param arr   待排序的数组
  5.      * @param left  待排序序列的左端点
  6.      * @param right 待排序序列的右端点
  7.      */
  8.     public static void mergeSort(int[] arr, int left, int right) {
  9.         /*递归结束条件：子序列的长度为1或0*/
  10.         if (left >= right) {
  11.             return;
  12.         }
  13.         int mid = left + (right - left) / 2;
  14.         /*当子序列长度小于等于阈值时采用插入排序进行优化*/
  15.         if (right - left + 1 <= INSERTION_SORT_THRESHOLD) {
  16.             insertionSort(arr, left, right);
  17.         } else {
  18.             /*递归地对左半部分进行归并排序*/
  19.             mergeSort(arr, left, mid);
  20.             /*递归地对右半部分进行归并排序*/
  21.             mergeSort(arr, mid + 1, right);
  22.             /*对于已经有序的两个子序列不进行合并操作*/
  23.             if (arr[mid] > arr[mid + 1]) {
  24.                 /*合并两个有序子序列*/
  25.                 merge(arr, left, mid, right);
  26.             }
  27.         }
  28.     }
  29.  
  30.     /**
  31.      * 插入排序算法（用于优化归并排序）
  32.      *
  33.      * @param arr   待排序的数组
  34.      * @param left  待排序序列的左端点
  35.      * @param right 待排序序列的右端点
  36.      */
  37.     private static void insertionSort(int[] arr, int left, int right) {
  38.         for (int i = left + 1; i <= right; i++) {
  39.             int temp = arr[i];
  40.             int j = i - 1;
  41.             while (j >= left && arr[j] > temp) {
  42.                 arr[j + 1] = arr[j];
  43.                 j--;
  44.             }
  45.             arr[j + 1] = temp;
  46.         }
  47.     }

（六）堆排序（Heap Sort）

基本知识介绍

堆排序是一种利用堆数据结构进行排序的算法，可以看作是一种选择排序。堆是一种特殊的树形数据结构，它满足堆的性质：对于每个非叶节点的值都大于等于（或小于等于）其左右子节点的值。在堆中，最大元素总是位于根节点，因此堆排序也称为选择排序的一种。

堆排序的基本思想是将待排序的序列构建成一个大根堆（或小根堆），然后将根节点（最大元素）与序列最后一个元素交换，然后对前面的序列重新构建堆，重复这个过程直到序列排序完成。

堆排序的时间复杂度为 O(n\log n)，其中 n$是待排序序列的长度，空间复杂度为 O(1)，是一种原地排序算法。

堆排序的具体步骤如下：

  1. 构建初始堆：将待排序序列构造成一个大根堆（或小根堆）。
  2. 将根节点与最后一个节点交换位置，最大值就移动到了序列末尾。
  3. 重新调整堆：将剩余 n-1 个节点重新构造成一个堆，重复步骤2直到排序完成。

由于堆排序对原序列的要求不高，适用于一些数据规模比较大的场景，因此在实际应用中被广泛使用。

具体代码展示

这里使用的是最大堆进行排序。堆排序的时间复杂度为 O(nlogn)，空间复杂度为 O(1)。

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. /**
  4.  * @author yanfengzhang
  5.  * @description 堆排序的时间复杂度为 O(nlogn)，空间复杂度为 O(1)。
  6.  * 使用的是最大堆进行排序
  7.  * @date 2023/4/16  00:13
  8.  */
  9. public class HeapSort {
  10.  
  11.     /**
  12.      * 堆排序算法
  13.      *
  14.      * @param arr 待排序的数组
  15.      */
  16.     public static void heapSort(int[] arr) {
  17.         if (arr == null || arr.length == 0) {
  18.             return;
  19.         }
  20.         int n = arr.length;
  21.         /*构建初始堆*/
  22.         for (int i = n / 2 - 1; i >= 0; i--) {
  23.             heapify(arr, i, n);
  24.         }
  25.         /*排序*/
  26.         for (int i = n - 1; i >= 0; i--) {
  27.             swap(arr, 0, i);
  28.             heapify(arr, 0, i);
  29.         }
  30.     }
  31.  
  32.     /**
  33.      * 对指定节点进行堆调整
  34.      *
  35.      * @param arr  待调整的数组
  36.      * @param i    待调整的节点
  37.      * @param size 堆的大小
  38.      */
  39.     private static void heapify(int[] arr, int i, int size) {
  40.         int largest = i;
  41.         /*左孩子节点*/
  42.         int l = 2 * i + 1;
  43.         /*右孩子节点*/
  44.         int r = 2 * i + 2;
  45.         if (l < size && arr[l] > arr[largest]) {
  46.             largest = l;
  47.         }
  48.         if (r < size && arr[r] > arr[largest]) {
  49.             largest = r;
  50.         }
  51.         if (largest != i) {
  52.             swap(arr, i, largest);
  53.             heapify(arr, largest, size);
  54.         }
  55.     }
  56.  
  57.     /**
  58.      * 交换数组中两个位置的元素
  59.      *
  60.      * @param arr 待交换元素所在的数组
  61.      * @param i   第一个元素的下标
  62.      * @param j   第二个元素的下标
  63.      */
  64.     private static void swap(int[] arr, int i, int j) {
  65.         int temp = arr[i];
  66.         arr[i] = arr[j];
  67.         arr[j] = temp;
  68.     }
  69.  
  70.     public static void main(String[] args) {
  71.         /*创建一个待排序的数组*/
  72.         int[] array = {5, 3, 8, 6, 4};
  73.         /*对数组进行排序*/
  74.         heapSort(array);
  75.         /*输出排序后的结果*/
  76.         for (int i = 0; i < array.length; i++) {
  77.             System.out.print(array[i] + " ");
  78.         }
  79.     }
  80.  
  81. }

扩展：Top K 问题分析

Top K 问题是指从一个集合中找出前 K 个最大或最小的元素的问题。通常，这个集合可以是一个数组、列表、堆、树等数据结构。

求解思路罗列

求最大的 K 个元素可以使用以下几种方法：

  1. 排序法：将集合进行排序，然后取前 K 个元素，时间复杂度为 O(NlogN)。
  2. 堆（优先队列）法：使用堆（通常是最大堆）来维护 K 个最大的元素，时间复杂度为 O(NlogK)。
  3. 快速选择法：基于快速排序的思想，通过每次选择一个基准元素进行分区，直到找到第 K 大的元素，时间复杂度为平均情况下 O(N)，最坏情况下 O(N^2)。
  4. 部分排序法：类似于快速选择，但不需要完全排序，只需要部分排序直到找到第 K 大的元素，时间复杂度为平均情况下 O(N)，最坏情况下 O(N^2)。

求最小的 K 个元素可以使用以下几种方法：

  1. 排序法：将集合进行排序，然后取前 K 个元素，时间复杂度为 O(NlogN)。
  2. 堆（优先队列）法：使用堆（通常是最小堆）来维护 K 个最小的元素，时间复杂度为 O(NlogK)。
  3. 快速选择法：类似于求最大 K 个元素的快速选择法，但是需要找第 K 小的元素，时间复杂度为平均情况下 O(N)，最坏情况下 O(N^2)。
  4. 部分排序法：类似于求最大 K 个元素的部分排序法，但是需要找第 K 小的元素，时间复杂度为平均情况下 O(N)，最坏情况下 O(N^2)。

这些方法在不同的情况下有不同的适用性和性能表现，具体选择哪种方法取决于问题的规模、要求和性能需求。

推荐解法分析

推荐使用堆（优先队列）法来解决 Top K 问题，因为它在时间复杂度和空间复杂度上都有较好的性能。堆是一种特殊的二叉树，通常使用数组来实现，可以高效地维护一个部分有序的集合。在解决 Top K 问题时，可以使用最大堆或最小堆来维护 K 个最大或最小的元素，具体选择最大堆还是最小堆取决于问题的要求。

使用堆的优势在于：

  1. 时间复杂度较低：堆的插入、删除、获取最值等操作的时间复杂度都是 O(logN)，其中 N 是集合的大小，对于大规模的数据集，性能较好。
  2. 空间复杂度较低：堆只需要额外的 O(K) 的空间来维护 K 个最大或最小的元素，相比于其他方法如排序法需要额外的 O(N) 空间来排序，节省了空间。
  3. 实现简单：使用优先队列（堆）的接口和方法较为简单，易于实现和理解。

需要注意的是，堆法的适用性和性能也受到具体问题的影响，例如对于较小规模的数据集或对时间复杂度要求不高的场合，排序法、快速选择法或部分排序法等方法也可能是合适的选择。因此，在选择解决 Top K 问题的算法时，应根据具体情况综合考虑问题规模、要求和性能需求。

最小 Top K代码展示

以下是使用堆排序（最小堆）求最小 Top K 的 Java 代码示例：

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.PriorityQueue;
  4.  
  5. /**
  6.  * @author yanfengzhang
  7.  * @description 使用堆排序（最小堆）求最小 Top K
  8.  * @date 2023/4/16  12:13
  9.  */
  10. public class MinTopK {
  11.     public static int[] getMinTopK(int[] arr, int k) {
  12.         if (arr == null || arr.length == 0 || k <= 0 || k > arr.length) {
  13.             return new int[0];
  14.         }
  15.  
  16.         /*创建一个最小堆，使用默认的初始容量和比较器*/
  17.         PriorityQueue minHeap = new PriorityQueue<>();
  18.  
  19.         /*遍历数组，将前 k 个元素加入最小堆*/
  20.         for (int i = 0; i < k; i++) {
  21.             minHeap.offer(arr[i]);
  22.         }
  23.  
  24.         /*遍历数组中剩余的元素，与最小堆的堆顶元素比较*/
  25.         /*若当前元素比堆顶元素小，则将堆顶元素出堆，当前元素入堆*/
  26.         for (int i = k; i < arr.length; i++) {
  27.             if (arr[i] < minHeap.peek()) {
  28.                 minHeap.poll();
  29.                 minHeap.offer(arr[i]);
  30.             }
  31.         }
  32.  
  33.         /*将最小堆中的元素取出放入结果数组*/
  34.         int[] result = new int[k];
  35.         for (int i = 0; i < k; i++) {
  36.             result[i] = minHeap.poll();
  37.         }
  38.  
  39.         return result;
  40.     }
  41.  
  42.     public static void main(String[] args) {
  43.         int[] arr = {10, 5, 8, 1, 7, 6};
  44.         int k = 3;
  45.         int[] result = getMinTopK(arr, k);
  46.         System.out.println("最小的 " + k + " 个元素是：");
  47.         for (int num : result) {
  48.             System.out.print(num + " ");
  49.         }
  50.     }
  51. }

最大 Top K代码展示

求最大 Top K 元素可以使用类似的思路，只是需要使用最大堆（大顶堆）来实现。以下是使用最大堆来求最大 Top K 元素的 Java 代码示例

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.PriorityQueue;
  4.  
  5. /**
  6.  * @author yanfengzhang
  7.  * @description 使用堆排序（最大堆）求最大 Top K
  8.  * @date 2023/4/16  12:14
  9.  */
  10. public class MaxTopK {
  11.     public static int[] getMaxTopK(int[] arr, int k) {
  12.         if (arr == null || arr.length == 0 || k <= 0 || k > arr.length) {
  13.             return new int[0];
  14.         }
  15.  
  16.         /*创建一个最大堆，使用自定义的比较器*/
  17.         PriorityQueue maxHeap = new PriorityQueue<>((a, b) -> b - a);
  18.  
  19.         /*遍历数组，将前 k 个元素加入最大堆*/
  20.         for (int i = 0; i < k; i++) {
  21.             maxHeap.offer(arr[i]);
  22.         }
  23.  
  24.         /*遍历数组中剩余的元素，与最大堆的堆顶元素比较*/
  25.         /*若当前元素比堆顶元素大，则将堆顶元素出堆，当前元素入堆*/
  26.         for (int i = k; i < arr.length; i++) {
  27.             if (arr[i] > maxHeap.peek()) {
  28.                 maxHeap.poll();
  29.                 maxHeap.offer(arr[i]);
  30.             }
  31.         }
  32.  
  33.         /*将最大堆中的元素取出放入结果数组*/
  34.         int[] result = new int[k];
  35.         for (int i = 0; i < k; i++) {
  36.             result[i] = maxHeap.poll();
  37.         }
  38.  
  39.         return result;
  40.     }
  41.  
  42.     public static void main(String[] args) {
  43.         int[] arr = {10, 5, 8, 1, 7, 6};
  44.         int k = 3;
  45.         int[] result = getMaxTopK(arr, k);
  46.         System.out.println("最大的 " + k + " 个元素是：");
  47.         for (int num : result) {
  48.             System.out.print(num + " ");
  49.         }
  50.     }
  51. }

扩展：使用堆排序思想实现优先级队列

对于一个优先级队列，每次插入一个元素后需要重新排序，可以使用堆排序的思想，将插入的元素加入堆中，然后进行堆排序，即可维护优先级队列的有序性。

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  6.  
  7. /**
  8.  * @author yanfengzhang
  9.  * @description 使用堆排序思想实现优先级队列
  10.  * 对于一个优先级队列，每次插入一个元素后需要重新排序，可以使用堆排序的思想，
  11.  * 将插入的元素加入堆中，然后进行堆排序，即可维护优先级队列的有序性。
  12.  * @date 2023/4/16  12:21
  13.  */
  14. public class PriorityQueueUseHeapextends Comparable> {
  15.     private List heap;
  16.  
  17.     public PriorityQueueUseHeap() {
  18.         heap = new ArrayList<>();
  19.     }
  20.  
  21.     public void insert(T item) {
  22.         heap.add(item);
  23.         int i = heap.size() - 1;
  24.         while (i > 0) {
  25.             int j = (i - 1) / 2;
  26.             if (heap.get(i).compareTo(heap.get(j)) <= 0) {
  27.                 break;
  28.             }
  29.             Collections.swap(heap, i, j);
  30.             i = j;
  31.         }
  32.     }
  33.  
  34.     public T peek() {
  35.         if (heap.size() == 0) {
  36.             return null;
  37.         }
  38.         return heap.get(0);
  39.     }
  40.  
  41.     public T remove() {
  42.         if (heap.size() == 0) {
  43.             return null;
  44.         }
  45.         T root = heap.get(0);
  46.         T last = heap.remove(heap.size() - 1);
  47.         if (heap.size() > 0) {
  48.             heap.set(0, last);
  49.             int i = 0;
  50.             while (i < heap.size()) {
  51.                 int left = i * 2 + 1;
  52.                 int right = i * 2 + 2;
  53.                 if (left >= heap.size()) {
  54.                     break;
  55.                 }
  56.                 int j = left;
  57.                 if (right < heap.size() && heap.get(right).compareTo(heap.get(left)) > 0) {
  58.                     j = right;
  59.                 }
  60.                 if (heap.get(i).compareTo(heap.get(j)) >= 0) {
  61.                     break;
  62.                 }
  63.                 Collections.swap(heap, i, j);
  64.                 i = j;
  65.             }
  66.         }
  67.         return root;
  68.     }
  69.  
  70.     public boolean isEmpty() {
  71.         return heap.isEmpty();
  72.     }
  73.  
  74.     public int size() {
  75.         return heap.size();
  76.     }
  77.  
  78.     public static void main(String[] args) {
  79.         /*创建一个自定义的最大堆*/
  80.         PriorityQueueUseHeap maxHeap = new PriorityQueueUseHeap<>();
  81.  
  82.         /*插入一些测试数据*/
  83.         maxHeap.insert(10);
  84.         maxHeap.insert(5);
  85.         maxHeap.insert(8);
  86.         maxHeap.insert(1);
  87.         maxHeap.insert(7);
  88.         maxHeap.insert(6);
  89.  
  90.         /*求最大的 k 个元素*/
  91.         int k = 3;
  92.  
  93.         System.out.println("最大的 " + k + " 个元素是：");
  94.         for (int i = 0; i < k; i++) {
  95.             Integer num = maxHeap.remove();
  96.             System.out.print(num + " ");
  97.         }
  98.     }
  99.  
  100. }

（七）计数排序（Counting Sort）

基本知识介绍

计数排序（Counting Sort）是一种用于对一组具有确定范围的非负整数进行排序的线性时间复杂度的排序算法。它不基于比较的方式，而是通过计算每个元素在输入数组中的出现次数，然后按照计数的结果将元素放置到有序的输出数组中。

计数排序的基本思想是将输入数组中的元素作为计数数组的索引，然后通过遍历输入数组，统计每个元素的出现次数，将统计结果保存在计数数组中。接着，根据计数数组中的统计结果，将输入数组中的元素放置到正确的位置上，从而得到排序后的输出数组。

计数排序的步骤如下：

  1. 找出输入数组中的最大值和最小值，确定计数数组的范围。
  2. 创建一个计数数组，长度为最大值和最小值之间的范围。
  3. 遍历输入数组，统计每个元素的出现次数，将统计结果保存在计数数组中。
  4. 根据计数数组中的统计结果，将输入数组中的元素放置到正确的位置上，从而得到排序后的输出数组。

计数排序的优点是排序速度快，时间复杂度为 O(n+k)，其中 n 是输入数组的大小，k 是输入数组中的最大值和最小值之间的范围。计数排序对于输入数据的范围没有限制，且适用于重复元素较多的情况。然而，计数排序需要额外的空间来保存计数数组，因此在输入数据范围较大时，会占用较多的空间。同时，计数排序只适用于非负整数的排序，对于其他类型的数据需要进行转换才能使用。

具体代码展示

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.Arrays;
  4.  
  5. /**
  6.  * @author yanfengzhang
  7.  * @description 计数排序（Counting Sort）
  8.  * 基本思想是将输入数组中的元素作为计数数组的索引，
  9.  * 然后通过遍历输入数组，统计每个元素的出现次数，将统计结果保存在计数数组中。
  10.  * 接着，根据计数数组中的统计结果，将输入数组中的元素放置到正确的位置上，从而得到排序后的输出数组。
  11.  * @date 2023/4/16  12:49
  12.  */
  13. public class CountingSort {
  14.     public static void countingSort(int[] arr) {
  15.         if (arr == null || arr.length <= 1) {
  16.             return;
  17.         }
  18.  
  19.         /*找出输入数组中的最大值和最小值*/
  20.         int min = arr[0];
  21.         int max = arr[0];
  22.         for (int i = 1; i < arr.length; i++) {
  23.             if (arr[i] < min) {
  24.                 min = arr[i];
  25.             }
  26.             if (arr[i] > max) {
  27.                 max = arr[i];
  28.             }
  29.         }
  30.  
  31.         /*创建计数数组并统计每个元素的出现次数*/
  32.         int[] count = new int[max - min + 1];
  33.         for (int i = 0; i < arr.length; i++) {
  34.             count[arr[i] - min]++;
  35.         }
  36.  
  37.         /*根据计数数组中的统计结果，将元素放置到正确的位置上*/
  38.         int index = 0;
  39.         for (int i = 0; i < count.length; i++) {
  40.             while (count[i] > 0) {
  41.                 arr[index++] = i + min;
  42.                 count[i]--;
  43.             }
  44.         }
  45.     }
  46.  
  47.     public static void main(String[] args) {
  48.         int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
  49.         System.out.println("Before sorting: " + Arrays.toString(arr));
  50.         countingSort(arr);
  51.         System.out.println("After sorting: " + Arrays.toString(arr));
  52.     }
  53. }

扩展：数组中有大量重复元素，如何高效地进行排序？

计数排序可以在线性时间复杂度内对包含大量重复元素的数组进行排序，因为它通过统计每个元素的出现次数并根据统计结果将元素放置到正确的位置上，避免了多次比较和交换操作。

  1.     /**
  2.      * 数组中有大量重复元素，如何高效地进行排序？
  3.      */
  4.     public static void countSort(int[] arr, int maxVal) {
  5.         int[] count = new int[maxVal + 1];
  6.  
  7.         /*统计每个元素的出现次数*/
  8.         for (int num : arr) {
  9.             count[num]++;
  10.         }
  11.  
  12.         /*将统计结果放置到正确的位置上*/
  13.         int idx = 0;
  14.         for (int i = 0; i <= maxVal; i++) {
  15.             while (count[i] > 0) {
  16.                 arr[idx++] = i;
  17.                 count[i]--;
  18.             }
  19.         }
  20.     }

扩展：给定一组学生成绩，如何按照成绩范围进行统计？

计数排序可以用于统计一组学生成绩的分布情况。可以将学生成绩作为输入数组，然后根据成绩的范围创建计数数组，并统计每个成绩范围内的学生人数。最后可以根据计数数组中的统计结果生成相应的统计报表。

  1.     /**
  2.      * 给定一组学生成绩，如何按照成绩范围进行统计？
  3.      */
  4.     public static int[] countSortGrades(int[] grades, int maxGrade) {
  5.         int[] count = new int[maxGrade + 1];
  6.  
  7.         /*统计每个成绩范围内的学生人数*/
  8.         for (int grade : grades) {
  9.             count[grade]++;
  10.         }
  11.  
  12.         return count;
  13.     }

扩展：如何对字符串数组按照字母顺序进行排序？

计数排序可以用于对字符串数组按照字母顺序进行排序。可以将字符串数组中的每个字符串转换为对应的字符数组，然后将字符数组的每个字符看作是一个整数，使用计数排序对字符数组进行排序，从而实现字符串数组的排序。

  1.     /**
  2.      * 如何对字符串数组按照字母顺序进行排序？
  3.      */
  4.     public static void countSortStrings(String[] arr) {
  5.         /*假设字符串只包含 ASCII 字符*/
  6.         int[] count = new int[256];
  7.  
  8.         /*统计每个字符的出现次数*/
  9.         for (String str : arr) {
  10.             for (char c : str.toCharArray()) {
  11.                 count[c]++;
  12.             }
  13.         }
  14.  
  15.         /*将统计结果生成排序后的字符串数组*/
  16.         int idx = 0;
  17.         for (int i = 0; i < 256; i++) {
  18.             while (count[i] > 0) {
  19.                 arr[idx++] = String.valueOf((char) i);
  20.                 count[i]--;
  21.             }
  22.         }
  23.     }

扩展：如何对多个关键字进行排序？

计数排序可以用于对多个关键字进行排序。可以将多个关键字组合成一个整数或者字符串作为排序的依据，然后使用计数排序对输入数组进行排序。

  1.     /**
  2.      * 如何对多个关键字进行排序？
  3.      */
  4.     public static void countSortMultiKeys(int[][] arr, int keyIdx, int maxVal) {
  5.         /*统计每个关键字的出现次数*/
  6.         int[] count = new int[maxVal + 1];
  7.         for (int[] row : arr) {
  8.             count[row[keyIdx]]++;
  9.         }
  10.  
  11.         /*计算每个关键字在输出数组中的起始索引*/
  12.         for (int i = 1; i <= maxVal; i++) {
  13.             count[i] += count[i - 1];
  14.         }
  15.  
  16.         /*创建临时数组存储排序结果*/
  17.         int[][] output = new int[arr.length][];
  18.         for (int i = arr.length - 1; i >= 0; i--) {
  19.             output[--count[arr[i][keyIdx]]] = arr[i];
  20.         }
  21.  
  22.         /*将排序结果复制到原数组*/
  23.         for (int i = 0; i < arr.length; i++) {
  24.             arr[i] = output[i];
  25.         }
  26.     }

相关扩展思路代码验证

  1. public static void main(String[] args) {
  2.         System.out.println("数组中有大量重复元素，如何高效地进行排序？ 验证测试");
  3.         int[] arr = {5, 2, 9, 1, 5, 6};
  4.         int maxVal = 9;
  5.  
  6.         System.out.println("排序前的数组：" + Arrays.toString(arr));
  7.         countSort(arr, maxVal);
  8.         System.out.println("排序后的数组：" + Arrays.toString(arr));
  9.  
  10.         System.out.println("给定一组学生成绩，如何按照成绩范围进行统计？ 验证测试");
  11.         int[] grades = {90, 87, 92, 78, 95, 89, 88, 92, 91, 88};
  12.         int maxGrade = 100;
  13.  
  14.         int[] count = countSortGrades(grades, maxGrade);
  15.  
  16.         System.out.println("成绩统计结果：");
  17.         for (int i = 0; i < count.length; i++) {
  18.             if (count[i] > 0) {
  19.                 System.out.println(i + ": " + count[i] + "人");
  20.             }
  21.         }
  22.  
  23.         System.out.println("如何对字符串数组按照字母顺序进行排序？ 验证测试");
  24.         String[] zimuArr = {"apple", "banana", "cherry", "date", "fig", "grape"};
  25.  
  26.         System.out.println("排序前的字符串数组：");
  27.         for (String str : zimuArr) {
  28.             System.out.print(str + " ");
  29.         }
  30.  
  31.         countSortStrings(zimuArr);
  32.  
  33.         System.out.println("\n排序后的字符串数组：");
  34.         for (String str : zimuArr) {
  35.             System.out.print(str + " ");
  36.         }
  37.  
  38.         System.out.println("如何对多个关键字进行排序？ 验证测试");
  39.         /*输入数据*/
  40.         int[][] keyWordArr = {{3, 5}, {1, 2}, {2, 3}, {2, 1}, {1, 4}, {3, 6}};
  41.  
  42.         /*原始数组*/
  43.         System.out.println("原始数组：");
  44.         for (int[] row : keyWordArr) {
  45.             System.out.println(Arrays.toString(row));
  46.         }
  47.  
  48.         /*调用 countSortMultiKeys 进行排序*/
  49.         countSortMultiKeys(keyWordArr, 0, 3);
  50.  
  51.         /*排序后的数组*/
  52.         System.out.println("排序后的数组：");
  53.         for (int[] row : keyWordArr) {
  54.             System.out.println(Arrays.toString(row));
  55.         }
  56.     }

（八）桶排序（Bucket Sort）

基本知识介绍

桶排序（Bucket Sort）是一种排序算法，它将输入数据分割成若干个桶（Bucket），然后对每个桶中的数据进行排序，最后将所有桶中的数据合并得到最终的排序结果。

桶排序的基本思想是将待排序的数据按照一定的范围划分成若干个桶，每个桶内的数据单独进行排序，可以使用任何一种排序算法，例如插入排序、快速排序等。然后，将所有的桶按照顺序依次合并，得到最终的排序结果。

桶排序的时间复杂度取决于两个因素：桶的个数和每个桶内数据的排序算法。如果每个桶内的数据是均匀分布的，那么桶排序的时间复杂度可以接近O(n)，其中n为待排序数据的个数。但是，如果桶的个数过于少或者过于多，都可能导致桶排序的性能下降。

桶排序适合用于处理大量数据且数据分布较为均匀的情况，例如对一段范围较大的浮点数进行排序。桶排序在处理大数据量时可以充分利用多核处理器的优势，同时也可以通过调整桶的个数和每个桶内数据的排序算法来进行性能优化。然而，需要注意的是，桶排序的空间复杂度较高，因为需要额外的空间来存储桶。

具体代码展示

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5.  
  6. /**
  7.  * @author yanfengzhang
  8.  * @description 桶排序（Bucket Sort）
  9.  * 将待排序的数据按照一定的范围划分成若干个桶，
  10.  * 每个桶内的数据单独进行排序，可以使用任何一种排序算法，例如插入排序、快速排序等。
  11.  * 然后，将所有的桶按照顺序依次合并，得到最终的排序结果。
  12.  * @date 2023/4/16  14:09
  13.  */
  14. public class BucketSort {
  15.     public static void bucketSort(double[] arr) {
  16.         int n = arr.length;
  17.  
  18.         /*创建桶*/
  19.         ArrayList[] buckets = new ArrayList[n];
  20.         for (int i = 0; i < n; i++) {
  21.             buckets[i] = new ArrayList<>();
  22.         }
  23.  
  24.         /*将元素分配到桶中*/
  25.         for (int i = 0; i < n; i++) {
  26.             int index = (int) (n * arr[i]);
  27.             buckets[index].add(arr[i]);
  28.         }
  29.  
  30.         /*对每个桶内的元素进行排序*/
  31.         for (int i = 0; i < n; i++) {
  32.             Collections.sort(buckets[i]);
  33.         }
  34.  
  35.         /*将桶中的元素合并到原数组中*/
  36.         int index = 0;
  37.         for (int i = 0; i < n; i++) {
  38.             for (int j = 0; j < buckets[i].size(); j++) {
  39.                 arr[index++] = buckets[i].get(j);
  40.             }
  41.         }
  42.     }
  43.  
  44.     public static void main(String[] args) {
  45.         double[] arr = {0.8, 0.2, 0.6, 0.4, 0.1, 0.9, 0.3, 0.5, 0.7};
  46.         System.out.println("原始数组：");
  47.         for (double num : arr) {
  48.             System.out.print(num + " ");
  49.         }
  50.         System.out.println();
  51.         bucketSort(arr);
  52.         System.out.println("排序后数组：");
  53.         for (double num : arr) {
  54.             System.out.print(num + " ");
  55.         }
  56.         System.out.println();
  57.     }
  58.  
  59. }

扩展：按照年龄对一组人员进行排序

假设有一组人员信息，包括姓名、年龄等属性，需要按照年龄对这组人员进行排序。可以使用桶排序，以年龄作为排序的关键字，将人员信息分配到不同的年龄桶中，再对每个年龄桶内的人员信息进行排序，最后合并所有桶内的人员信息即可。具体代码展示：

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import lombok.Data;
  4.  
  5. import java.util.ArrayList;
  6. import java.util.Collections;
  7. import java.util.Comparator;
  8.  
  9. /**
  10.  * @author yanfengzhang
  11.  * @description 按照年龄对一组人员进行排序：
  12.  * 假设有一组人员信息，包括姓名、年龄等属性，需要按照年龄对这组人员进行排序。
  13.  * 可以使用桶排序，以年龄作为排序的关键字，将人员信息分配到不同的年龄桶中，
  14.  * 再对每个年龄桶内的人员信息进行排序，最后合并所有桶内的人员信息即可。
  15.  * @date 2023/4/16  14:12
  16.  */
  17. public class BucketSortByAge {
  18.     public static void bucketSortByAge(Person[] arr, int maxAge) {
  19.         if (arr == null || arr.length <= 1 || maxAge <= 0) {
  20.             return;
  21.         }
  22.  
  23.         /*创建年龄桶*/
  24.         ArrayList[] ageBuckets = new ArrayList[maxAge + 1];
  25.         for (int i = 0; i <= maxAge; i++) {
  26.             ageBuckets[i] = new ArrayList<>();
  27.         }
  28.  
  29.         /*将人员信息分配到年龄桶中*/
  30.         for (Person person : arr) {
  31.             int age = person.getAge();
  32.             ageBuckets[age].add(person);
  33.         }
  34.  
  35.         /*对每个年龄桶内的人员信息进行排序*/
  36.         int idx = 0;
  37.         for (ArrayList bucket : ageBuckets) {
  38.             if (bucket != null && !bucket.isEmpty()) {
  39.                 /*对每个年龄桶内的人员信息进行排序，这里可以使用任何合适的排序算法*/
  40.                 Collections.sort(bucket, new Comparator() {
  41.                     @Override
  42.                     public int compare(Person o1, Person o2) {
  43.                         /*按照年龄升序排序*/
  44.                         return o1.getAge() - o2.getAge();
  45.                     }
  46.                 });
  47.  
  48.                 /*将排序后的人员信息合并到原数组中*/
  49.                 for (Person person : bucket) {
  50.                     arr[idx++] = person;
  51.                 }
  52.             }
  53.         }
  54.     }
  55.  
  56.     @Data
  57.     public static class Person {
  58.         private String name;
  59.         private int age;
  60.  
  61.         public Person(String name, int age) {
  62.             this.name = name;
  63.             this.age = age;
  64.         }
  65.     }
  66.  
  67.     public static void main(String[] args) {
  68.         /*示例数据*/
  69.         Person[] persons = new Person[6];
  70.         persons[0] = new Person("Alice", 25);
  71.         persons[1] = new Person("Bob", 30);
  72.         persons[2] = new Person("Charlie", 22);
  73.         persons[3] = new Person("Dave", 25);
  74.         persons[4] = new Person("Eve", 22);
  75.         persons[5] = new Person("Frank", 30);
  76.  
  77.         System.out.println("排序前：");
  78.         for (Person person : persons) {
  79.             System.out.println(person.getName() + " - " + person.getAge() + "岁");
  80.         }
  81.  
  82.         /*调用桶排序算法进行排序*/
  83.         bucketSortByAge(persons, 30);
  84.  
  85.         System.out.println("\n排序后：");
  86.         for (Person person : persons) {
  87.             System.out.println(person.getName() + " - " + person.getAge() + "岁");
  88.         }
  89.     }
  90. }

扩展：对一组考试成绩进行排序

假设有一组学生的考试成绩，需要按照成绩进行排序。可以使用桶排序，以考试成绩作为排序的关键字，将学生信息分配到不同的成绩桶中，再对每个成绩桶内的学生信息进行排序，最后合并所有桶内的学生信息即可。具体代码展示

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import lombok.Data;
  4.  
  5. import java.util.ArrayList;
  6. import java.util.Collections;
  7. import java.util.Comparator;
  8.  
  9. /**
  10.  * @author yanfengzhang
  11.  * @description 对一组考试成绩进行排序
  12.  * 假设有一组学生的考试成绩，需要按照成绩进行排序。
  13.  * 可以使用桶排序，以考试成绩作为排序的关键字，将学生信息分配到不同的成绩桶中，
  14.  * 再对每个成绩桶内的学生信息进行排序，最后合并所有桶内的学生信息即可。
  15.  * @date 2023/4/16  14:18
  16.  */
  17. public class BucketSortByScore {
  18.     public static void bucketSortByScore(Student[] arr, int maxScore) {
  19.         if (arr == null || arr.length <= 1 || maxScore <= 0) {
  20.             return;
  21.         }
  22.  
  23.         /*创建成绩桶*/
  24.         ArrayList[] scoreBuckets = new ArrayList[maxScore + 1];
  25.         for (int i = 0; i <= maxScore; i++) {
  26.             scoreBuckets[i] = new ArrayList<>();
  27.         }
  28.  
  29.         /*将学生信息分配到成绩桶中*/
  30.         for (Student student : arr) {
  31.             int score = student.getScore();
  32.             scoreBuckets[score].add(student);
  33.         }
  34.  
  35.         /*对每个成绩桶内的学生信息进行排序*/
  36.         int idx = 0;
  37.         for (ArrayList bucket : scoreBuckets) {
  38.             if (bucket != null && !bucket.isEmpty()) {
  39.                 /*对每个成绩桶内的学生信息进行排序，这里可以使用任何合适的排序算法*/
  40.                 Collections.sort(bucket, new Comparator() {
  41.                     @Override
  42.                     public int compare(Student o1, Student o2) {
  43.                         /*按照成绩降序排序*/
  44.                         return o2.getScore() - o1.getScore();
  45.                     }
  46.                 });
  47.  
  48.                 /*将排序后的学生信息合并到原数组中*/
  49.                 for (Student student : bucket) {
  50.                     arr[idx++] = student;
  51.                 }
  52.             }
  53.         }
  54.     }
  55.  
  56.     @Data
  57.     public static class Student {
  58.         private String name;
  59.         private int score;
  60.  
  61.         /*构造函数*/
  62.         public Student(String name, int score) {
  63.             this.name = name;
  64.             this.score = score;
  65.         }
  66.     }
  67.  
  68.     public static void main(String[] args) {
  69.         /*示例数据*/
  70.         Student[] students = new Student[6];
  71.         students[0] = new Student("Alice", 90);
  72.         students[1] = new Student("Bob", 78);
  73.         students[2] = new Student("Charlie", 88);
  74.         students[3] = new Student("Dave", 95);
  75.         students[4] = new Student("Eve", 82);
  76.         students[5] = new Student("Frank", 88);
  77.  
  78.         System.out.println("排序前：");
  79.         for (Student student : students) {
  80.             System.out.println(student.getName() + " - 成绩：" + student.getScore());
  81.         }
  82.  
  83.         /*调用桶排序算法进行排序*/
  84.         bucketSortByScore(students, 100);
  85.  
  86.         System.out.println("\n排序后：");
  87.         for (Student student : students) {
  88.             System.out.println(student.getName() + " - 成绩：" + student.getScore());
  89.         }
  90.     }
  91. }

扩展：对一组具有相同前缀的字符串进行排序

假设有一组字符串，这些字符串都具有相同的前缀，需要按照字符串的字典序进行排序。可以使用桶排序，以字符串的第一个字符作为排序的关键字，将字符串分配到不同的字符桶中，再对每个字符桶内的字符串进行排序，最后合并所有桶内的字符串即可。具体代码展示

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5.  
  6. /**
  7.  * @author yanfengzhang
  8.  * @description 对一组具有相同前缀的字符串进行排序
  9.  * 假设有一组字符串，这些字符串都具有相同的前缀，需要按照字符串的字典序进行排序。
  10.  * 可以使用桶排序，以字符串的第一个字符作为排序的关键字，将字符串分配到不同的字符桶中，
  11.  * 再对每个字符桶内的字符串进行排序，最后合并所有桶内的字符串即可。
  12.  * @date 2023/4/16  14:20
  13.  */
  14. public class BucketSortByPrefix {
  15.     public static void bucketSortByPrefix(String[] arr, int prefixLength) {
  16.         if (arr == null || arr.length <= 1 || prefixLength <= 0) {
  17.             return;
  18.         }
  19.  
  20.         /*创建字符桶*/
  21.         /*假设字符串只包含小写字母，共26个桶*/
  22.         ArrayList[] charBuckets = new ArrayList[26];
  23.         for (int i = 0; i < 26; i++) {
  24.             charBuckets[i] = new ArrayList<>();
  25.         }
  26.  
  27.         /*将字符串分配到字符桶中*/
  28.         for (String str : arr) {
  29.             charBuckets[str.charAt(prefixLength - 1) - 'a'].add(str);
  30.         }
  31.  
  32.         /*对每个字符桶内的字符串进行排序*/
  33.         int idx = 0;
  34.         for (ArrayList bucket : charBuckets) {
  35.             if (bucket != null && !bucket.isEmpty()) {
  36.                 /*对每个字符桶内的字符串进行排序，这里可以使用任何合适的排序算法*/
  37.                 Collections.sort(bucket);
  38.  
  39.                 /*将排序后的字符串合并到原数组中*/
  40.                 for (String str : bucket) {
  41.                     arr[idx++] = str;
  42.                 }
  43.             }
  44.         }
  45.     }
  46.  
  47.     public static void main(String[] args) {
  48.         /*示例数据*/
  49.         String[] strings = new String[]{"apple", "banana", "bear", "bell", "cat", "dog", "duck"};
  50.  
  51.         System.out.println("排序前：");
  52.         for (String str : strings) {
  53.             System.out.println(str);
  54.         }
  55.  
  56.         /*调用桶排序算法进行排序*/
  57.         bucketSortByPrefix(strings, 1);
  58.  
  59.         System.out.println("\n排序后：");
  60.         for (String str : strings) {
  61.             System.out.println(str);
  62.         }
  63.     }
  64. }

（九）基数排序（Radix Sort）

基本知识介绍

基数排序（Radix Sort）是一种非比较性的排序算法，它根据元素的位数或字符的位置来进行排序。基数排序的基本思想是将待排序的元素按照各位或字符的值，从低位到高位依次进行排序，直到最高位排序完成后，整个序列就变成了有序的。

基数排序通常用于对整数、字符串等具有固定位数的数据进行排序，例如对手机号码、身份证号码等进行排序。

以下是基数排序的完整步骤：

  1. 确定排序的位数或字符的位置，从最低位（个位）到最高位（最高位）。
  2. 对每一位或字符进行计数排序或桶排序，根据位数或字符的值将元素分配到不同的桶或计数数组中。
  3. 将所有桶或计数数组中的元素按照顺序合并到一起，形成新的排序序列。
  4. 重复步骤2和步骤3，直到最高位排序完成后，整个序列就变成了有序的。

具体代码展示

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.Arrays;
  4.  
  5. /**
  6.  * @author yanfengzhang
  7.  * @description 基数排序（Radix Sort）
  8.  * 根据元素的位数或字符的位置来进行排序。
  9.  * 基数排序的基本思想是将待排序的元素按照各位或字符的值，从低位到高位依次进行排序，
  10.  * 直到最高位排序完成后，整个序列就变成了有序的。
  11.  * @date 2023/4/16  14:39
  12.  */
  13. public class RadixSort {
  14.     /**
  15.      * 基数排序函数
  16.      */
  17.     public static void radixSort(int[] arr) {
  18.         /*获取数组中的最大值，确定排序的位数*/
  19.         int max = getMax(arr);
  20.  
  21.         /*对每一位进行计数排序*/
  22.         for (int exp = 1; max / exp > 0; exp *= 10) {
  23.             countSort(arr, exp);
  24.         }
  25.     }
  26.  
  27.     /**
  28.      * 获取数组中的最大值
  29.      */
  30.     public static int getMax(int[] arr) {
  31.         int max = arr[0];
  32.         for (int i = 1; i < arr.length; i++) {
  33.             if (arr[i] > max) {
  34.                 max = arr[i];
  35.             }
  36.         }
  37.         return max;
  38.     }
  39.  
  40.     /**
  41.      * 对数组按照指定位数进行计数排序
  42.      */
  43.     public static void countSort(int[] arr, int exp) {
  44.         int n = arr.length;
  45.         int[] output = new int[n];
  46.         int[] count = new int[10];
  47.  
  48.         /*统计当前位的数字出现次数*/
  49.         for (int i = 0; i < n; i++) {
  50.             count[(arr[i] / exp) % 10]++;
  51.         }
  52.  
  53.         /*计算累计次数*/
  54.         for (int i = 1; i < 10; i++) {
  55.             count[i] += count[i - 1];
  56.         }
  57.  
  58.         /*从后往前遍历原数组，按照当前位的数字放置到输出数组中*/
  59.         for (int i = n - 1; i >= 0; i--) {
  60.             output[count[(arr[i] / exp) % 10] - 1] = arr[i];
  61.             count[(arr[i] / exp) % 10]--;
  62.         }
  63.  
  64.         /*将输出数组复制回原数组*/
  65.         System.arraycopy(output, 0, arr, 0, n);
  66.     }
  67.  
  68.     public static void main(String[] args) {
  69.         int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};
  70.         System.out.println("原始数组: " + Arrays.toString(arr));
  71.  
  72.         radixSort(arr);
  73.  
  74.         System.out.println("排序后数组: " + Arrays.toString(arr));
  75.     }
  76. }

扩展：对一组手机号码进行排序

假设有一组手机号码，需要按照手机号码进行排序。可以使用基数排序，以手机号码的每一位数字作为排序的关键字，从左到右进行排序。代码展示:

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.Arrays;
  4.  
  5. /**
  6.  * @author yanfengzhang
  7.  * @description 对一组手机号码进行排序
  8.  * 假设有一组手机号码，需要按照手机号码进行排序。
  9.  * 可以使用基数排序，以手机号码的每一位数字作为排序的关键字，从左到右进行排序。
  10.  * @date 2023/4/16  14:43
  11.  */
  12. public class PhoneNumRadixSort {
  13.     /**
  14.      * 获取手机号码的指定位数字
  15.      */
  16.     public static int getDigit(long phoneNum, int d) {
  17.         if (d >= 1 && d <= 11) {
  18.             String numStr = String.valueOf(phoneNum);
  19.             if (numStr.length() >= d) {
  20.                 return Integer.parseInt(String.valueOf(numStr.charAt(numStr.length() - d)));
  21.             }
  22.             /*若手机号码不足 d 位，则在高位补0*/
  23.             return 0;
  24.         }
  25.         return -1;
  26.     }
  27.  
  28.     /**
  29.      * 使用基数排序对手机号码进行排序
  30.      */
  31.     public static void radixSort(long[] arr) {
  32.         /*进行基数排序*/
  33.         for (int d = 11; d >= 1; d--) {
  34.             /*计数数组，用于存储每个位数字出现的次数*/
  35.             int[] count = new int[10];
  36.             /*临时数组，用于存储排序结果*/
  37.             long[] output = new long[arr.length];
  38.  
  39.             /*统计每个位数字出现的次数*/
  40.             for (long phoneNum : arr) {
  41.                 int digit = getDigit(phoneNum, d);
  42.                 count[digit]++;
  43.             }
  44.  
  45.             /*计算每个位数字的累计次数*/
  46.             for (int i = 1; i < 10; i++) {
  47.                 count[i] += count[i - 1];
  48.             }
  49.  
  50.             /*将手机号码按当前位数字放入临时数组中*/
  51.             for (int i = arr.length - 1; i >= 0; i--) {
  52.                 int digit = getDigit(arr[i], d);
  53.                 output[--count[digit]] = arr[i];
  54.             }
  55.  
  56.             /*将临时数组中的结果复制回原数组*/
  57.             System.arraycopy(output, 0, arr, 0, arr.length);
  58.         }
  59.     }
  60.  
  61.     public static void main(String[] args) {
  62.         long[] arr = {18888888888L, 13333333333L, 17777777777L, 16666666666L, 19999999999L};
  63.         System.out.println("排序前：" + Arrays.toString(arr));
  64.         radixSort(arr);
  65.         System.out.println("排序后：" + Arrays.toString(arr));
  66.     }
  67. }

扩展：对一组身份证号码进行排序

假设有一组身份证号码，需要按照身份证号码进行排序。可以使用基数排序，以身份证号码的每一位数字作为排序的关键字，从左到右进行排序。代码展示:

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.Arrays;
  4.  
  5. /**
  6.  * @author yanfengzhang
  7.  * @description 对一组身份证号码进行排序
  8.  * 假设有一组身份证号码，需要按照身份证号码进行排序。
  9.  * 可以使用基数排序，以身份证号码的每一位数字作为排序的关键字，从左到右进行排序。
  10.  * @date 2023/4/16  14:52
  11.  */
  12. public class IDNumberRadixSort {
  13.     /**
  14.      * 获取身份证号码的指定位数字
  15.      */
  16.     public static int getDigit(char ch, int d) {
  17.         return Character.getNumericValue(ch) / (int) Math.pow(10, d - 1) % 10;
  18.     }
  19.  
  20.     /**
  21.      * 使用基数排序对身份证号码进行排序
  22.      */
  23.     public static void radixSort(String[] arr) {
  24.         /*获取身份证号码的最大位数*/
  25.         int maxDigits = 0;
  26.         for (String id : arr) {
  27.             int digits = id.length();
  28.             if (digits > maxDigits) {
  29.                 maxDigits = digits;
  30.             }
  31.         }
  32.  
  33.         /*进行基数排序*/
  34.         for (int d = maxDigits; d >= 1; d--) {
  35.             /*计数数组，用于存储每个位数字出现的次数*/
  36.             int[] count = new int[10];
  37.             /*临时数组，用于存储排序结果*/
  38.             String[] output = new String[arr.length];
  39.  
  40.             /*统计每个位数字出现的次数*/
  41.             for (String id : arr) {
  42.                 if (id.length() >= d) {
  43.                     int digit = getDigit(id.charAt(id.length() - d), 1);
  44.                     count[digit]++;
  45.                 }
  46.             }
  47.  
  48.             /*计算每个位数字的累计次数*/
  49.             for (int i = 1; i < 10; i++) {
  50.                 count[i] += count[i - 1];
  51.             }
  52.  
  53.             /*将身份证号码按当前位数字放入临时数组中*/
  54.             for (int i = arr.length - 1; i >= 0; i--) {
  55.                 if (arr[i].length() >= d) {
  56.                     int digit = getDigit(arr[i].charAt(arr[i].length() - d), 1);
  57.                     output[--count[digit]] = arr[i];
  58.                 } else {
  59.                     output[--count[0]] = arr[i];
  60.                 }
  61.             }
  62.  
  63.             /*将临时数组中的结果复制回原数组*/
  64.             System.arraycopy(output, 0, arr, 0, arr.length);
  65.         }
  66.     }
  67.  
  68.     public static void main(String[] args) {
  69.         String[] arr = {"320583199901010001", "320583199901010002", "320583199901010003", "320583199901010004",
  70.                 "320583199901010005"};
  71.         System.out.println("排序前：" + Arrays.toString(arr));
  72.         radixSort(arr);
  73.         System.out.println("排序后：" + Arrays.toString(arr));
  74.     }
  75.  
  76. }

扩展：对一组IP地址进行排序

假设有一组IP地址，需要按照IP地址进行排序。可以使用基数排序，以IP地址的每一位数字作为排序的关键字，从左到右进行排序。代码展示:

  1. package org.zyf.javabasic.letcode.sort;
  2.  
  3. import java.util.Arrays;
  4.  
  5. /**
  6.  * @author yanfengzhang
  7.  * @description 对一组IP地址进行排序
  8.  * 假设有一组IP地址，需要按照IP地址进行排序。
  9.  * 可以使用基数排序，以IP地址的每一位数字作为排序的关键字，从左到右进行排序。
  10.  * @date 2023/4/16  14:56
  11.  */
  12. public class IPAddressesRadixSort {
  13.     /**
  14.      * 获取IP地址的指定位数字
  15.      */
  16.     public static int getDigit(String ip, int d) {
  17.         String[] segments = ip.split("\\.");
  18.         if (segments.length == 4 && d >= 1 && d <= 4) {
  19.             return Integer.parseInt(segments[d - 1]);
  20.         }
  21.         return -1;
  22.     }
  23.  
  24.     /**
  25.      * 使用基数排序对IP地址进行排序
  26.      */
  27.     public static void radixSort(String[] arr) {
  28.         /*进行基数排序*/
  29.         for (int d = 4; d >= 1; d--) {
  30.             /*计数数组，用于存储每个位数字出现的次数*/
  31.             int[] count = new int[256];
  32.             /*临时数组，用于存储排序结果*/
  33.             String[] output = new String[arr.length];
  34.  
  35.             /*统计每个位数字出现的次数*/
  36.             for (String ip : arr) {
  37.                 int digit = getDigit(ip, d);
  38.                 count[digit]++;
  39.             }
  40.  
  41.             /*计算每个位数字的累计次数*/
  42.             for (int i = 1; i < 256; i++) {
  43.                 count[i] += count[i - 1];
  44.             }
  45.  
  46.             /*将IP地址按当前位数字放入临时数组中*/
  47.             for (int i = arr.length - 1; i >= 0; i--) {
  48.                 int digit = getDigit(arr[i], d);
  49.                 output[--count[digit]] = arr[i];
  50.             }
  51.  
  52.             /*将临时数组中的结果复制回原数组*/
  53.             System.arraycopy(output, 0, arr, 0, arr.length);
  54.         }
  55.     }
  56.  
  57.     public static void main(String[] args) {
  58.         String[] arr = {"192.168.1.2", "192.168.1.1", "10.0.0.1", "10.0.0.2", "172.16.0.1", "172.16.0.2"};
  59.         System.out.println("排序前：" + Arrays.toString(arr));
  60.         radixSort(arr);
  61.         System.out.println("排序后：" + Arrays.toString(arr));
  62.     }
  63.  
  64. }

四、总结

还是找一张图来总结吧

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览62532 人正在系统学习中
注：本文转载自blog.csdn.net的张彦峰ZYF的文章"https://blog.csdn.net/xiaofeng10330111/article/details/127557182"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！