1. 算法基础：选择排序与冒泡排序深度解析
在算法学习的道路上，排序算法是最基础也是最重要的基石。今天我们将重点探讨两种经典的排序算法：选择排序和冒泡排序。虽然它们的效率不如快速排序或归并排序那样高效，但理解它们的工作原理对于培养算法思维至关重要。
选择排序的核心思想是：每次从未排序的部分中找到最小（或最大）的元素，放到已排序部分的末尾。这个过程就像我们在超市挑选水果，每次都选择最成熟的那个放入购物篮。
冒泡排序则像气泡在水中上升的过程，通过相邻元素的比较和交换，将较大的元素逐步"冒泡"到数组的末端。这两种算法的时间复杂度都是O(n²)，适合小规模数据的排序。
2. 选择排序的实现与优化
2.1 基础选择排序实现
让我们先来看选择排序的标准实现：
cpp复制void selectionSort(vector<int>& arr) {
int n = arr.size();
for (int i = 0; i < n-1; i++) {
int min_idx = i;
for (int j = i+1; j < n; j++) {
if (arr[j] < arr[min_idx]) {
min_idx = j;
}
}
swap(arr[i], arr[min_idx]);
}
}
这个实现有几个关键点需要注意：
- 外层循环控制已排序部分的边界
- 内层循环负责在未排序部分寻找最小值
- 每次外层循环只进行一次交换操作
提示：选择排序的一个特点是交换次数较少，最多进行n-1次交换，这在某些特定场景下可能是一个优势。
2.2 选择排序的优化方向
虽然选择排序的基本形式已经相当简单，但我们仍可以进行一些优化：
- 双向选择排序：同时寻找最小和最大元素，可以减少大约一半的循环次数
- 提前终止：如果在某次遍历中没有发生交换，可以提前终止算法
- 使用哨兵：减少边界条件的判断
这里给出双向选择排序的实现示例：
cpp复制void bidirectionalSelectionSort(vector<int>& arr) {
int left = 0, right = arr.size() - 1;
while (left < right) {
int min_idx = left, max_idx = right;
// 确保min_idx <= max_idx
if (arr[min_idx] > arr[max_idx]) {
swap(arr[min_idx], arr[max_idx]);
}
for (int i = left + 1; i < right; i++) {
if (arr[i] < arr[min_idx]) {
min_idx = i;
} else if (arr[i] > arr[max_idx]) {
max_idx = i;
}
}
swap(arr[left], arr[min_idx]);
swap(arr[right], arr[max_idx]);
left++;
right--;
}
}
3. 冒泡排序的细节与改进
3.1 标准冒泡排序实现
冒泡排序的基本实现如下：
cpp复制void bubbleSort(vector<int>& arr) {
int n = arr.size();
for (int i = 0; i < n-1; i++) {
for (int j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
swap(arr[j], arr[j+1]);
}
}
}
}
冒泡排序的特点包括：
- 每次内层循环都会将当前未排序部分的最大元素"冒泡"到最后
- 需要进行大量的相邻元素比较和交换
- 最坏情况下需要进行约n²/2次比较和交换
3.2 冒泡排序的优化策略
原始的冒泡排序效率不高，但我们可以通过以下几种方式进行优化：
- 提前终止：如果某一轮没有发生交换，说明数组已经有序
- 记录最后交换位置：下一轮只需要比较到这个位置即可
- 鸡尾酒排序：双向交替进行冒泡
优化后的冒泡排序实现：
cpp复制void optimizedBubbleSort(vector<int>& arr) {
int n = arr.size();
bool 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]) {
swap(arr[j], arr[j+1]);
swapped = true;
}
}
if (!swapped) break; // 提前终止
}
}
鸡尾酒排序（双向冒泡）的实现：
cpp复制void cocktailSort(vector<int>& arr) {
bool swapped = true;
int start = 0, end = arr.size() - 1;
while (swapped) {
swapped = false;
// 从左到右
for (int i = start; i < end; i++) {
if (arr[i] > arr[i+1]) {
swap(arr[i], arr[i+1]);
swapped = true;
}
}
if (!swapped) break;
end--;
swapped = false;
// 从右到左
for (int i = end-1; i >= start; i--) {
if (arr[i] > arr[i+1]) {
swap(arr[i], arr[i+1]);
swapped = true;
}
}
start++;
}
}
4. LeetCode排序相关问题实战
4.1 颜色分类问题（75题）
这个问题本质上是荷兰国旗问题，可以使用三指针法解决：
cpp复制void sortColors(vector<int>& nums) {
int low = 0, mid = 0, high = nums.size() - 1;
while (mid <= high) {
if (nums[mid] == 0) {
swap(nums[low++], nums[mid++]);
} else if (nums[mid] == 1) {
mid++;
} else {
swap(nums[mid], nums[high--]);
}
}
}
这个算法的精妙之处在于：
- low指针指向0的右边界
- high指针指向2的左边界
- mid指针用于遍历数组
- 时间复杂度O(n)，空间复杂度O(1)
4.2 合并两个有序数组（88题）
虽然题目要求合并两个有序数组，但我们可以利用选择排序的思想：
cpp复制void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int i = m - 1, j = n - 1, k = m + n - 1;
while (i >= 0 && j >= 0) {
if (nums1[i] > nums2[j]) {
nums1[k--] = nums1[i--];
} else {
nums1[k--] = nums2[j--];
}
}
while (j >= 0) {
nums1[k--] = nums2[j--];
}
}
这个解法从后向前填充，避免了额外的空间开销，时间复杂度O(m+n)。
5. 排序算法的性能比较与选择
5.1 时间复杂度分析
| 算法 | 最好情况 | 平均情况 | 最坏情况 | 空间复杂度 | 稳定性 |
|---|---|---|---|---|---|
| 选择排序 | O(n²) | O(n²) | O(n²) | O(1) | 不稳定 |
| 冒泡排序 | O(n) | O(n²) | O(n²) | O(1) | 稳定 |
| 插入排序 | O(n) | O(n²) | O(n²) | O(1) | 稳定 |
5.2 何时使用选择排序或冒泡排序
虽然这两种排序算法效率不高，但在某些特定场景下仍有使用价值：
- 小规模数据：当n较小时，简单算法的常数因子可能使其实际运行时间更优
- 特定硬件环境：在某些嵌入式系统中，简单算法更容易实现且资源消耗少
- 教学目的：理解这些基础算法有助于掌握更复杂的算法
- 部分有序数据：优化后的冒泡排序对部分有序数据表现较好
6. 常见错误与调试技巧
6.1 选择排序常见错误
- 内层循环范围错误：容易写成j=0而不是j=i+1
- 交换条件错误：应该在找到最小值后再交换，而不是每次比较都交换
- 边界条件处理不当：忘记处理空数组或单元素数组的情况
6.2 冒泡排序调试技巧
- 可视化调试：打印每一轮排序后的数组状态
- 交换计数器：记录交换次数，帮助分析算法效率
- 边界检查：特别注意数组末尾的处理
注意：在实现排序算法时，务必添加对输入数组为空或只有一个元素的特殊处理，这是常见的错误来源。
7. 算法思维的延伸与应用
理解选择排序和冒泡排序不仅是为了掌握这两种特定算法，更重要的是培养解决问题的思维方式：
- 分治思想：将问题分解为更小的子问题
- 贪心策略：每次选择当前最优的解
- 循环不变式：理解并证明算法的正确性
- 时间复杂度分析：评估算法效率的基本方法
这些思维模式可以应用到更复杂的算法问题中，如动态规划、图算法等。
在实际编程中，虽然我们通常会使用标准库中的排序函数，但理解这些基础算法的原理对于解决更复杂的问题至关重要。例如，当需要自定义排序规则或处理特定数据结构时，这些基础知识就会派上用场。