高级排序算法（二）：归并排序与堆排序详解

引言

在上一章中，我们探讨了高效的快速排序及其分治思想。这一次，我们将继续探索两种同样重要的排序算法：归并排序（Merge Sort） 和 堆排序（Heap Sort）。
它们与快速排序一样，都是O(n log n)时间复杂度的排序算法，但实现方式和适用场景却各有不同。归并排序在稳定性和分布式场景中表现优异，而堆排序则在内存有限的情况下表现突出。

接下来，我们将一起深入剖析这两种排序算法的原理、实现与应用。

一、归并排序（Merge Sort）

1.1 算法思想

归并排序是典型的分治法应用，采用“分而治之”的思想，递归地将数组分成两部分，分别排序后再合并。

1.2 算法过程

分解：将数组从中间分成两部分，直到每部分只有一个元素（显然是有序的）。
合并：将两个有序的子数组合并成一个有序数组。
递归：对每个子数组重复上述过程。

1.3 C语言实现


#include <stdio.h>
#include <stdlib.h>// 合并两个有序子数组
void merge(int arr[], int left, int mid, int right) {int n1 = mid - left + 1;  // 左子数组的大小int n2 = right - mid;     // 右子数组的大小// 创建临时数组int* L = (int*)malloc(n1 * sizeof(int));int* R = (int*)malloc(n2 * sizeof(int));// 复制数据到临时数组for (int i = 0; i < n1; i++) L[i] = arr[left + i];for (int j = 0; j < n2; j++) R[j] = arr[mid + 1 + j];// 合并临时数组到原数组int i = 0, j = 0, k = left;while (i < n1 && j < n2) {if (L[i] <= R[j]) {arr[k++] = L[i++];} else {arr[k++] = R[j++];}}// 复制剩余元素while (i < n1) arr[k++] = L[i++];while (j < n2) arr[k++] = R[j++];// 释放临时数组free(L);free(R);
}// 归并排序
void mergeSort(int arr[], int left, int right) {if (left < right) {int mid = left + (right - left) / 2;  // 防止溢出mergeSort(arr, left, mid);           // 排序左半部分mergeSort(arr, mid + 1, right);      // 排序右半部分merge(arr, left, mid, right);        // 合并两部分}
}int main() {int arr[] = {38, 27, 43, 3, 9, 82, 10};int n = sizeof(arr) / sizeof(arr[0]);mergeSort(arr, 0, n - 1);printf("排序后的数组: ");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}return 0;
}

1.4 时间和空间复杂度

时间复杂度：
- 每次分解需要log n层。
- 每次合并需要O(n)时间。
- 总体时间复杂度为O(n log n)。
空间复杂度：
- 由于需要额外的临时数组，空间复杂度为O(n)。

1.5 优点与缺点

优点：
- 时间复杂度始终为O(n log n)，无最坏情况。
- 稳定排序，适用于需要保持顺序的场景。
缺点：
- 需要额外的存储空间，空间复杂度较高。

二、堆排序（Heap Sort）

2.1 算法思想

堆排序是基于堆数据结构的排序算法，通过构建最大堆或最小堆实现排序。

最大堆：堆顶（根节点）是堆中最大的元素。
最小堆：堆顶（根节点）是堆中最小的元素。

堆排序的过程可以分为两个步骤：

构建堆：将无序数组调整为一个最大堆。
排序：依次将堆顶元素（最大值）与最后一个元素交换，并调整堆。

2.2 C语言实现

构建堆的核心：向下调整（Heapify）


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 temp = arr[i];arr[i] = arr[largest];arr[largest] = temp;heapify(arr, n, largest);}
}

堆排序主函数


void heapSort(int arr[], int n) {// 构建最大堆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);}
}int main() {int arr[] = {12, 11, 13, 5, 6, 7};int n = sizeof(arr) / sizeof(arr[0]);heapSort(arr, n);printf("排序后的数组: ");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}return 0;
}

2.3 时间和空间复杂度

时间复杂度：
- 构建堆需要O(n)时间。
- 排序过程需要O(n log n)时间。
- 总体时间复杂度为O(n log n)。
空间复杂度：
- 原地排序，无额外空间需求，空间复杂度为O(1)。

2.4 优点与缺点

优点：
- 时间复杂度为O(n log n)，无最坏情况。
- 不需要额外存储空间，适合内存有限的场景。
缺点：
- 不稳定排序。
- 实现相对复杂，调整堆时需要更多代码。

三、对比与总结

特性	归并排序	堆排序
时间复杂度	O(n log n)	O(n log n)
空间复杂度	O(n)	O(1)
稳定性	稳定	不稳定
适用场景	数据量大，且对稳定性有要求	内存有限，且对稳定性无要求