目录
一、使用场景对比
| 排序算法 | 基本思路 | 平均时间复杂度 | 空间复杂度 | 稳定性 | 主要使用场景 |
|---|---|---|---|---|---|
| 冒泡排序 | 重复遍历列表，比较相邻元素，如果顺序错误就交换，直到没有需要交换的元素。 | O(n²) | O(1) | 稳定 | 教学用途，理论理解。实际应用极少，因为效率太低。 |
| 选择排序 | 每次从未排序部分中选择最小（或最大）的元素，放到已排序部分的末尾。 | O(n²) | O(1) | 不稳定 | 数据量非常小，且对内存空间限制严格（因为原地排序）。实际应用较少。 |
| 插入排序 | 将列表视为已排序和未排序两部分，逐个将未排序的元素插入到已排序部分的正确位置。 | O(n²) | O(1) | 稳定 | 小规模或基本有序的数据集。常作为快速排序等算法处理小数组的优化子过程。 |
| 快速排序 | 分治法。选择一个基准值，将数组分为小于基准和大于基准的两部分，递归地对子数组进行排序。 | O(n log n)， O(n²)（最坏，已排序） | O(log n) | 不稳定 | 通用且高效的排序算法，是大多数编程语言标准库的默认实现。适用于大规模随机数据。 |
| 归并排序 | 分治法。递归地将数组分成两半分别排序，然后将两个已排序的子数组合并成一个有序数组。 | O(n log n) | O(n) | 稳定 | 需要稳定排序且不在乎O(n)额外空间的场景。也非常适合外部排序（数据在磁盘上）。 |
| 堆排序 | 利用二叉堆（通常是大顶堆）这种数据结构，不断取出堆顶元素（最大值）并调整堆。 | O(n log n) | O(1) | 不稳定 | 需要原地排序且希望最坏情况也能保证O(n log n)性能的场景。例如在内存受限的嵌入式系统中。 |
| 计数排序 | 不是比较排序。通过统计每个元素出现的次数，然后计算元素的位置来实现排序。 | O(n + k) | O(n + k) | 稳定 | 适用于数据范围k不大的非负整数排序，例如对年龄、考试成绩排序。 |
| 基数排序 | 不是比较排序。按照位或关键字，从低位到高位（或反之）进行稳定的排序（通常用计数排序作为子过程）。 | O(d * (n + k)) | O(n + k) | 稳定 | 适用于多关键字排序或位数固定的整数、字符串排序，例如手机号、字典单词排序。 |
时间复杂度:
-
O(n²)： 随着数据量n的增长，时间成本呈平方级增长，性能较差。
-
O(n log n)： 性能最优的比较排序算法所能达到的平均时间复杂度。
-
O(n + k) / O(d * (n + k))： 非比较排序的时间复杂度，性能可以突破O(n log n)的下限，但对输入数据有特定要求。
空间复杂度:
-
O(1)： 原地排序，排序过程中只用到常数级别的额外空间（如几个变量）。
-
O(n)： 需要与待排序数组同样大小的额外空间（如归并排序）。
-
O(k)： 需要额外空间来存储计数数组（如计数排序）。
稳定性:
-
稳定： 如果两个相等的元素在排序后的序列中相对顺序与排序前一致，则算法是稳定的。
-
例如： 原序列
[（A, 3), （B, 2), （C, 2）]按数字排序后，(B, 2)和(C, 2)的相对顺序不变，结果为[（B, 2), （C, 2), （A, 3）]。
-
-
不稳定： 无法保证相等元素的相对顺序。
选择建议：
-
大规模通用排序： 快速排序（综合最快，标准库首选）。
-
需要稳定且不怕占用空间： 归并排序。
-
小规模（<1000）或基本有序： 插入排序（性能优于冒泡）。
-
原地排序且要保证最坏情况的性能（内存受限）： 堆排序（原地排序）。
-
非负整数且范围较小： 计数排序、基数排序。
-
Java 的内置排序：
Arrays.sort()对于基本数据类型使用双轴快速排序的变体，对于对象数组的排序使用的是名为 TimSort 的优化算法，它是归并排序和插入排序的混合体，利用了归并排序的稳定性。
二、常用排序
2.1 快速排序
核心思想：快速排序使用分治策略。主要为三个步骤：
-
分解：从数组中选择一个元素作为基准。通过一次分区操作，将数组重新排列，使得所有比基准值小的元素都放在基准前面，所有比基准值大的元素都放在基准后面（相等的数可以放到任一边）。在这次分区操作结束后，该基准就处于数组的中间位置。这个操作称为分区操作。
-
递归：递归地将小于基准值的子数组和大于基准值的子数组进行排序。
-
合并：因为子数组都是原址排序的，所以不需要合并操作，数组本身就已经是有序的了。
时间复杂度：
-
平均情况：O(n log n)。这是快速排序最常见的情况。每次分区操作大约将数组分成两半。
-
最好情况：O(n log n)。发生在每次分区都能将数组完美地分成大小相等的两部分时。
-
最坏情况：O(n²)。发生在每次选择的 pivot 都是当前子数组中的最小或最大元素时（例如，数组已经升序或降序排序，并且总是选择最后一个元素作为 pivot）。这会导致极其不平衡的分区。
空间复杂度：
-
O(log n)。空间消耗主要来自递归调用栈。在平均情况下，递归树的深度是 O(log n)。在最坏情况下，递归树的深度是 O(n)。
稳定性：
-
快速排序是不稳定的排序算法。在分区过程中，相等的元素可能会因为与 pivot 的比较而被交换到不同的相对位置。
方案一：使用 Lomuto 分区方案（易于理解）
// 快速排序主函数
public static void quickSort(int[] arr, int low, int high) {
if (low < high) {
// 对数组进行分区，获取基准点索引
int pivotIndex = partition(arr, low, high);
// 递归排序左子数组（小于基准的部分）
quickSort(arr, low, pivotIndex - 1);
// 递归排序右子数组（大于基准的部分）
quickSort(arr, pivotIndex + 1, high);
}
}
// 分区函数 - 核心逻辑
private static int partition(int[] arr, int low, int high) {
// 选择最后一个元素作为基准
int pivot = arr[high];
// 指向小于基准的区域的最后一个元素
int i = low - 1;
// 遍历当前分区
for (int j = low; j < high; j++) {
// 如果当前元素小于或等于基准
if (arr[j] <= pivot) {
i++;
// 将小于基准的元素交换到左侧区域
swap(arr, i, j);
}
}
// 将基准元素放到正确位置（i+1）
swap(arr, i + 1, high);
// 返回基准元素的最终位置
return i + 1;
}
// 交换数组中两个元素的位置
private static void swap(int[] arr, int i, int j) {
if (i != j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}优化建议：随机选择基准，避免最坏情况时间复杂度
// 在partition函数开头添加：
int randomIndex = low + (int)(Math.random() * (high - low + 1));
swap(arr, randomIndex, high);方案二：使用 Hoare 分区方案（更高效，交换次数更少）
public class QuickSortHoare {
public static void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi); // 注意这里包含了pi位置
quickSort(arr, pi + 1, high);
}
}
/*
* Hoare 分区方案
* 通常选择中间元素作为基准（pivot），但可以选择第一个或任意一个
* 两个指针从两端向中间扫描，交换逆序对
* 当指针相遇时返回相遇点的索引
*/
private static int partition(int[] arr, int low, int high) {
// 选择第一个元素作为基准（也可以选择中间的元素来优化）
int pivot = arr[low];
int i = low - 1;
int j = high + 1;
while (true) {
// 从左向右找到第一个 >= pivot 的元素
do {
i++;
} while (arr[i] < pivot);
// 从右向左找到第一个 <= pivot 的元素
do {
j--;
} while (arr[j] > pivot);
// 如果指针相遇或交叉，返回j作为分界点
if (i >= j) {
return j;
}
// 交换这两个逆序的元素
swap(arr, i, j);
}
}
// 交换数组中两个元素的位置
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}2.2 归并排序
核心思想：归并排序采用分治策略，将数组分成两半，分别排序，然后合并两个有序数组。
-
分：递归地将当前数组平均分割成两个子数组，直到每个子数组只包含一个元素（一个元素的数组自然是有序的）。
-
治：将两个已经排序的子数组合并成一个更大的有序数组，直到最终合并成一个完整的排序数组。
时间复杂度：
-
最好、最坏、平均情况均为 O(n log n)。
-
“分”的阶段：数组每次被一分为二，形成一棵递归树，树的高度是 log₂n。
-
“治”的阶段：在每一层递归中，
merge操作需要处理 n 个元素，所以每一层的时间复杂度是 O(n)。 -
总时间复杂度 = 树的高度 × 每层的工作量 = O(log n) × O(n) = O(n log n)。
空间复杂度：
-
O(n)。
-
这是归并排序的主要缺点。
merge操作需要一個与原始数组等大的临时数组来存放合并后的结果。 -
此外，递归调用需要 O(log n) 的栈空间。
-
总空间复杂度由临时数组主导，为 O(n)。
稳定性：
-
归并排序是稳定的排序算法。
-
在
merge操作中，当两个元素相等时，我们可以优先取左边子数组的元素，这样就保证了它们原始的相对顺序不被改变。
链表排序：归并排序非常适合于对链表进行排序，因为它只需要改变节点的链接关系，而不需要像数组那样开辟大量临时空间，空间复杂度可以降至 O(1)。
// 自底向上的迭代实现（非递归）
public class MergeSortIterative {
public static void mergeSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
int n = arr.length;
int[] temp = new int[n];
// size 表示当前要合并的子数组的大小，从1开始，每次加倍
for (int size = 1; size < n; size *= 2) {
// left 表示每次要合并的两个子数组的起始位置
for (int left = 0; left < n - size; left += 2 * size) {
int mid = left + size - 1;
// 确保右子数组的边界不越界
int right = Math.min(left + 2 * size - 1, n - 1);
merge(arr, left, mid, right, temp);
}
}
}
// merge 方法与递归版本中的完全相同
private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
int i = left;
int j = mid + 1;
int t = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[t++] = arr[i++];
} else {
temp[t++] = arr[j++];
}
}
while (i <= mid) {
temp[t++] = arr[i++];
}
while (j <= right) {
temp[t++] = arr[j++];
}
t = 0;
while (left <= right) {
arr[left++] = temp[t++];
}
}
// ... printArray 和 main 方法与上一个例子相同 ...
}// 标准的自顶向下递归实现（最直观）
public class MergeSort {
// 主方法，供用户调用
public static void mergeSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
int[] temp = new int[arr.length]; // 创建临时数组，避免在递归中反复创建
sort(arr, 0, arr.length - 1, temp);
}
// 递归排序函数
private static void sort(int[] arr, int left, int right, int[] temp) {
// 递归终止条件：子数组只有一个元素或为空
if (left < right) {
int mid = left + (right - left) / 2; // 防止溢出，等同于 (left+right)/2
// 递归分解左边
sort(arr, left, mid, temp);
// 递归分解右边
sort(arr, mid + 1, right, temp);
// 合并左右两个有序子数组
merge(arr, left, mid, right, temp);
}
}
// 核心：合并两个有序子数组 arr[left...mid] 和 arr[mid+1...right]
private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
int i = left; // 左子数组的起始索引
int j = mid + 1; // 右子数组的起始索引
int t = 0; // 临时数组的当前索引
// 1. 比较两个子数组的元素，将较小的放入temp
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) { // 这里 <= 保证了算法的稳定性
temp[t++] = arr[i++];
} else {
temp[t++] = arr[j++];
}
}
// 2. 将左子数组中剩余的元素拷贝到temp
while (i <= mid) {
temp[t++] = arr[i++];
}
// 3. 将右子数组中剩余的元素拷贝到temp
while (j <= right) {
temp[t++] = arr[j++];
}
// 4. 将temp数组中合并好的数据拷贝回原数组arr
t = 0;
while (left <= right) {
arr[left++] = temp[t++];
}
}
// 辅助方法：打印数组
public static void printArray(int[] arr) {
for (int value : arr) {
System.out.print(value + " ");
}
System.out.println();
}
// 测试代码
public static void main(String[] args) {
int[] arr = {38, 27, 43, 3, 9, 82, 10};
System.out.println("原始数组:");
printArray(arr);
mergeSort(arr);
System.out.println("\n排序后数组:");
printArray(arr); // 输出: 3 9 10 27 38 43 82
}
}2.3 插入排序
核心思想：将数组分为“已排序”和“未排序”两部分。初始时，已排序部分只有一个元素。然后依次将未排序部分的元素“插入”到已排序部分的正确位置，直到所有元素都插入完毕。
时间复杂度：
-
最坏情况：数组完全逆序。每个新元素都需要与所有已排序元素比较并移动。需要
1 + 2 + ... + (n-1) = n(n-1)/2次比较和移动。所以是 O(n²)。 -
最好情况：数组已经有序。每个新元素只需要比较一次（与前一个元素），无需移动。所以是 O(n)。
-
平均情况：O(n²)。
空间复杂度：
-
排序过程只在原数组内部进行移位和插入，只需要常数级别的额外空间（用于存储待插入的元素和循环索引）。所以是 O(1)，属于原地排序。
稳定性：
-
插入排序是稳定的排序算法。
-
当比较两个相等的元素时，后插入的元素会放在先插入元素的后面，不会改变它们原有的相对顺序。
public class InsertionSort {
// 使用while实现
public static void insertionSort(int[] arr) {
int n = arr.length;
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
// 将大于key的元素向后移动
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
// 使用for实现
public static void insertionSortForLoop(int[] arr) {
int n = arr.length;
for (int i = 1; i < n; i++) {
int key = arr[i];
int j;
// 使用 for 循环来寻找插入点并移动元素
for (j = i - 1; j >= 0 && arr[j] > key; j--) {
arr[j + 1] = arr[j];
}
arr[j + 1] = key;
}
}
}2.4 堆排序
核心思想：是一种基于二叉堆数据结构的比较排序算法，具有O(n log n)的时间复杂度，且是原地排序（只需要常数级额外空间），是一种选择排序。
-
二叉堆：一种完全二叉树，可分为：
-
最大堆：每个节点的值都大于或等于其子节点的值
-
最小堆：每个节点的值都小于或等于其子节点的值
-
-
堆的性质：
-
对于索引i的元素：
-
父节点位置：(i-1)/2
-
左子节点位置：2*i + 1
-
右子节点位置：2*i + 2
-
-
时间复杂度：
-
构建堆：O(n)
-
每次堆调整：O(log n)
-
总体：O(n log n)
空间复杂度：O(1)（原地排序）
稳定性：不稳定（相同元素可能会改变相对位置）
public class HeapSort {
public static void heapSort(int[] arr) {
int n = arr.length;
// 构建最大堆（从最后一个非叶子节点开始）
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
// 逐个提取堆顶元素
for (int i = n - 1; i > 0; i--) {
// 将当前堆顶元素（最大值）与末尾元素交换
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// 调整剩余元素的堆结构
heapify(arr, i, 0);
}
}
// 调整堆（最大堆）
private static void heapify(int[] arr, int n, int i) {
int largest = i; // 初始化最大值为当前节点
int left = 2 * i + 1; // 左子节点
int right = 2 * i + 2; // 右子节点
// 如果左子节点存在且大于当前最大值
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
// 如果右子节点存在且大于当前最大值
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
// 如果最大值不是当前节点，交换并继续调整
if (largest != i) {
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;
// 递归调整受影响的子树
heapify(arr, n, largest);
}
}
// 测试代码
public static void main(String[] args) {
int[] arr = {12, 11, 13, 5, 6, 7};
System.out.println("原始数组:");
printArray(arr);
heapSort(arr);
System.out.println("排序后数组:");
printArray(arr);
}
private static void printArray(int[] arr) {
for (int value : arr) {
System.out.print(value + " ");
}
System.out.println();
}
}2.5 计数排序
核心思想：通过统计每个元素出现的次数，然后直接计算每个元素在排序后数组中的位置。计数排序是一种非比较型整数排序算法，特别适用于对一定范围内的整数进行排序。
-
确定范围：找出待排序数组中的最大值和最小值，确定数值范围
-
计数：创建一个计数数组，统计每个数值出现的次数
-
累加计数：将计数数组转换为位置索引数组（累加计数）
-
排序：根据位置索引数组，将元素放到正确的位置上
时间复杂度：O(n + k)，其中k是整数的范围
空间复杂度：O(n + k)
稳定性：稳定排序算法
/**
* 计数排序实现
* @param arr 待排序数组
* @return 排序后的数组
*/
public static int[] countingSort(int[] arr) {
if (arr.length == 0) {
return arr;
}
// 1. 找出数组中的最大值和最小值
int min = arr[0];
int max = arr[0];
for (int num : arr) {
if (num < min) {
min = num;
}
if (num > max) {
max = num;
}
}
// 2. 创建计数数组并统计每个元素出现的次数
int range = max - min + 1;
int[] count = new int[range];
for (int num : arr) {
count[num - min]++;
}
// 3. 将计数数组转换为位置索引数组（累加计数）
for (int i = 1; i < range; i++) {
count[i] += count[i - 1];
}
// 4. 创建输出数组，根据计数数组将元素放到正确位置
int[] output = new int[arr.length];
// 从后往前遍历原数组，保证排序的稳定性
for (int i = arr.length - 1; i >= 0; i--) {
int num = arr[i];
int position = count[num - min] - 1;
output[position] = num;
count[num - min]--;
}
return output;
}
/**
* 简化版计数排序（不保持稳定性）
*/
public static int[] simpleCountingSort(int[] arr) {
if (arr.length == 0) {
return arr;
}
// 找出数组中的最大值和最小值
int min = arr[0];
int max = arr[0];
for (int num : arr) {
if (num < min) min = num;
if (num > max) max = num;
}
// 创建计数数组
int range = max - min + 1;
int[] count = new int[range];
// 统计每个元素出现的次数
for (int num : arr) {
count[num - min]++;
}
// 根据计数数组重构排序后的数组
int index = 0;
for (int i = 0; i < range; i++) {
while (count[i] > 0) {
arr[index++] = i + min;
count[i]--;
}
}
return arr;
}2.6 基数排序
核心思想：其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。是一种非比较型整数排序算法。
-
确定最大数的位数：找出数组中最大数字的位数，这决定了需要多少轮排序
-
按位排序：从最低位开始，对每一位进行稳定排序（通常使用计数排序）
-
重复排序：对每一位重复上述过程，直到最高位
时间复杂度：O(d*(n+k))，其中d是最大位数，n是元素数量，k是基数（通常为10）
空间复杂度：O(n+k)，需要额外的空间来存储临时数组
举例：
假设我们要排序的数组是
[170, 45, 75, 90, 802, 24, 2, 66]：第一轮（按个位数排序）：
170 → 0
45 → 5
75 → 5
90 → 0
802 → 2
24 → 4
2 → 2
66 → 6
排序后：
[170, 90, 802, 2, 24, 45, 75, 66]第二轮（按十位数排序）：[802, 2, 24, 45, 66, 170, 75, 90]
第三轮（按百位数排序）：[2, 24, 45, 66, 75, 90, 170, 802]
import java.util.Arrays;
public class RadixSort {
public static void radixSort(int[] arr) {
if (arr == null || arr.length <= 1) {
return;
}
// 找出数组中的最大值，确定最大位数
int max = Arrays.stream(arr).max().getAsInt();
// 从最低位开始，对每一位进行计数排序
for (int exp = 1; max / exp > 0; exp *= 10) {
countingSort(arr, exp);
}
}
private static void countingSort(int[] arr, int exp) {
int n = arr.length;
int[] output = new int[n]; // 输出数组
int[] count = new int[10]; // 计数数组，0-9共10个数字
// 初始化计数数组
Arrays.fill(count, 0);
// 统计每个数字出现的次数
for (int i = 0; i < n; i++) {
int digit = (arr[i] / exp) % 10;
count[digit]++;
}
// 将计数数组转换为位置索引
for (int i = 1; i < 10; i++) {
count[i] += count[i - 1];
}
// 构建输出数组（从后向前遍历以保证稳定性）
for (int i = n - 1; i >= 0; i--) {
int digit = (arr[i] / exp) % 10;
output[count[digit] - 1] = arr[i];
count[digit]--;
}
// 将排序结果复制回原数组
System.arraycopy(output, 0, arr, 0, n);
}
// 测试代码
public static void main(String[] args) {
int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};
System.out.println("排序前: " + Arrays.toString(arr));
radixSort(arr);
System.out.println("排序后: " + Arrays.toString(arr));
}
}三、其他排序
3.1 冒泡排序
核心思想：重复地遍历要排序的列表，一次比较相邻的两个元素，如果它们的顺序错误就把它们交换过来。这个过程就像最大的气泡（最大的数字）一次次地“沉”到列表的底部。
时间复杂度：
-
最坏情况：数组完全逆序。需要比较
(n-1) + (n-2) + ... + 1 = n(n-1)/2次。所以是 O(n²)。 -
最好情况：数组已经有序。优化后的算法只需要遍历一次（n-1次比较）就会退出。所以是 O(n)。
-
平均情况：O(n²)。
空间复杂度：
-
排序过程只在原数组内部进行交换，只需要一个临时变量用于交换。所以是 O(1)，属于原地排序。
// 冒泡排序实现
public static void bubbleSort(int[] arr) {
int n = arr.length;
// 优化标志：如果某次遍历没有交换，说明已排序完成
boolean swapped;
for (int i = 0; i < n - 1; i++) {
swapped = false;
// 每次遍历将最大的元素"冒泡"到最后
for (int j = 0; j < n - i - 1; j++) {
// 比较相邻元素
if (arr[j] > arr[j + 1]) {
// 交换 arr[j] 和 arr[j+1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = true;
}
}
// 如果没有发生交换，说明数组已经有序
if (!swapped) {
break;
}
}
}3.2 选择排序
核心思想：不断地从剩余未排序的元素中选择最小（或最大）的那个，将其放到已排序序列的末尾。
时间复杂度：
-
最好、最坏、平均情况均为 O(n²)。
-
无论数组是否有序，算法都需要进行
(n-1) + (n-2) + ... + 1 = n(n-1)/2次比较来寻找最小值。这是一个固定的次数。 -
交换操作的次数是 O(n)，最多进行
n-1次交换。这比冒泡排序（交换次数多）要好一些。
空间复杂度：
-
排序过程只在原数组内部进行交换，只需要常数级别的额外空间（用于存储最小值的索引和临时交换变量）。所以是 O(1)，属于原地排序。
稳定性：
-
选择排序是不稳定的排序算法。
public class SelectionSort {
public static void selectionSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
// 交换找到的最小元素和第一个未排序元素
if (minIndex != i) { // 小小的优化，避免不必要的交换
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
}
}
}
扫一扫
5220
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
