蓝桥杯 Java B 组之排序算法（冒泡、选择、插入排序）
Day 1：排序算法（冒泡、选择、插入排序）
一、排序算法基础
排序算法是 蓝桥杯 Java B 组的高频考点，主要考察：
- 手写基础排序算法（冒泡、选择、插入）
- 理解时间复杂度
- 使用排序解决实际问题（如求 Top K）
二、三大基础排序算法
1. 冒泡排序（Bubble Sort）
思想：
- 两两比较相邻元素
- 较大的元素向后移动
- 最多执行 n-1 轮
- 每一轮都把最大数“冒泡”到最后
- 原理：冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
时间复杂度
- 最坏情况（逆序）：O(n^2)
- 最好情况（已排序）：O(n)（优化版）
- 平均时间复杂度：O(n^2)
- 空间复杂度：O(1)（原地排序）
✅ 代码实现
public class BubbleSort {
public static void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// 交换 arr[j+1] 和 arr[j]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
bubbleSort(arr);
for (int num : arr) {
System.out.print(num + " ");
}
}
}2. 选择排序（Selection Sort）
思想：
- 每轮从未排序部分选择最小的元素
- 将其放到前面
- 进行 n-1 轮操作
- 原理：选择排序首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
时间复杂度
- 最坏情况：O(n^2)
- 最好情况：O(n^2)
- 平均时间复杂度：O(n^2)
- 空间复杂度：O(1)（原地排序）
✅ 代码实现
import java.util.Arrays;
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; // 找到最小值索引
}
}
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
public static void main(String[] args) {
int[] arr = {64, 25, 12, 22, 11};
selectionSort(arr);
System.out.println(Arrays.toString(arr));
}
}3. 插入排序（Insertion Sort）
思想：
- 从第二个元素开始
- 将当前元素插入到前面已排序部分的正确位置
- 依次处理剩余元素
- 原理：插入排序是将未排序数据插入到已排序序列的合适位置。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
时间复杂度
- 最坏情况：O(n^2)（逆序）
- 最好情况：O(n)（已排序）
- 平均时间复杂度：O(n^2)
- 空间复杂度：O(1)（原地排序）
✅ 代码实现
import java.util.Arrays;
public class InsertionSort {
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;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j]; // 后移
j--;
}
arr[j + 1] = key; // 插入合适位置
}
}
public static void main(String[] args) {
int[] arr = {12, 11, 13, 5, 6};
insertionSort(arr);
System.out.println(Arrays.toString(arr));
}
}三、应用题：求 Top K
题目描述
输入一个数组，求前 K 大的元素。
输入：arr = [3, 1, 5, 6, 2, 8, 7], K = 3
输出：[8, 7, 6]
✅ 解法 1：排序后取前 K 个（O(nlogn)）
import java.util.Arrays;
public class TopK {
public static int[] topK(int[] arr, int k) {
Arrays.sort(arr); // 默认升序
int[] result = new int[k];
for (int i = 0; i < k; i++) {
result[i] = arr[arr.length - 1 - i]; // 取最大的 k 个
}
return result;
}
public static void main(String[] args) {
int[] arr = {3, 1, 5, 6, 2, 8, 7};
System.out.println(Arrays.toString(topK(arr, 3)));
}
}✅ 解法 2：使用最小堆（O(nlogK)）
import java.util.PriorityQueue;
public class TopKHeap {
public static int[] topK(int[] arr, int k) {
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
for (int num : arr) {
minHeap.add(num);
if (minHeap.size() > k) {
minHeap.poll(); // 维持小顶堆
}
}
int[] result = new int[k];
for (int i = k - 1; i >= 0; i--) {
result[i] = minHeap.poll();
}
return result;
}
public static void main(String[] args) {
int[] arr = {3, 1, 5, 6, 2, 8, 7};
System.out.println(Arrays.toString(topK(arr, 3)));
}
}四、蓝桥杯排序常考点
| 考点 | 典型题目 | 难点 |
| 冒泡排序 | 手写冒泡排序 | 优化提前终止 |
| 选择排序 | 找第 K 小的数 | 减少交换次数 |
| 插入排序 | 手写插入排序 | 插入位置的查找 |
| Top K 问题 | 求前 K 大/小 | 使用堆优化 |
五、易错点总结
✅ 冒泡排序未优化
if (!swapped) break; // ✅ 提前终止
✅ Arrays.sort(arr) 默认是升序 ✅ PriorityQueue 默认是小顶堆
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
✅ 排序后索引变化
arr.sort((a, b) -> b - a); // ✅ 降序
复习建议
✅ 自己手写排序代码，理解内部逻辑
✅ 练习求 Top K 问题，熟悉 PriorityQueue
✅ 分析时间复杂度，选择合适排序方法