算法入门排序算法：归并排序
一、什么是归并排序？
归并排序（Merge Sort）是一种采用分治策略（Divide and Conquer）的高效排序算法，由约翰·冯·诺依曼于1945年发明。它是稳定排序算法的典范，也是第一个在最坏情况下仍然保持O(n log n)时间复杂度的排序算法。
归并排序的核心思想是：将一个大问题分解成若干个小问题，分别解决后再将结果合并。就像整理一副扑克牌，先把牌分成两半分别整理，然后再将两个有序的半副牌合并成一整副有序的牌。
二、归并排序的工作原理
归并排序的工作过程可以分为三个主要步骤：
- 分解（Divide）：将待排序的数组递归地分成两半，直到每个子数组只包含一个元素
- 解决（Conquer）：对每个子数组进行排序（单个元素自然有序）
- 合并（Merge）：将两个已排序的子数组合并成一个新的有序数组
这个过程体现了计算机科学中经典的"分而治之"思想，通过递归将复杂问题简化为基本情况的处理。
三、归并排序的Java实现
下面是归并排序的完整Java实现，包含递归和迭代两种版本：
import java.util.Arrays;
public class MergeSort {
// 归并排序主方法（递归版本）
public static void mergeSort(int[] array, int left, int right) {
if (left < right) {
// 找出中间位置
int mid = left + (right - left) / 2;
System.out.println("分解: 左数组[" + left + "-" + mid + "], 右数组[" + (mid+1) + "-" + right + "]");
// 递归排序左半部分
mergeSort(array, left, mid);
// 递归排序右半部分
mergeSort(array, mid + 1, right);
// 合并两个有序子数组
merge(array, left, mid, right);
}
}
// 合并两个有序子数组
private static void merge(int[] array, int left, int mid, int right) {
System.out.println("合并: 左数组[" + left + "-" + mid + "], 右数组[" + (mid+1) + "-" + right + "]");
// 创建临时数组存放合并结果
int[] temp = new int[right - left + 1];
int i = left; // 左子数组起始索引
int j = mid + 1; // 右子数组起始索引
int k = 0; // 临时数组索引
// 比较两个子数组的元素，按顺序放入临时数组
while (i <= mid && j <= right) {
if (array[i] <= array[j]) {
temp[k++] = array[i++];
} else {
temp[k++] = array[j++];
}
}
// 将左子数组剩余元素复制到临时数组
while (i <= mid) {
temp[k++] = array[i++];
}
// 将右子数组剩余元素复制到临时数组
while (j <= right) {
temp[k++] = array[j++];
}
// 将临时数组复制回原数组
System.arraycopy(temp, 0, array, left, temp.length);
System.out.println("合并结果: " + Arrays.toString(Arrays.copyOfRange(array, left, right + 1)));
}
// 迭代版本的归并排序（自底向上）
public static void iterativeMergeSort(int[] array) {
int n = array.length;
System.out.println("开始迭代归并排序...");
// 从大小为1的子数组开始，逐步倍增
for (int currSize = 1; currSize < n; currSize = 2 * currSize) {
System.out.println("当前子数组大小: " + currSize);
for (int leftStart = 0; leftStart < n - 1; leftStart += 2 * currSize) {
int mid = Math.min(leftStart + currSize - 1, n - 1);
int rightEnd = Math.min(leftStart + 2 * currSize - 1, n - 1);
System.out.println("合并: [" + leftStart + "-" + mid + "] 和 [" + (mid+1) + "-" + rightEnd + "]");
merge(array, leftStart, mid, rightEnd);
}
}
}
// 并行归并排序（简化版）
public static void parallelMergeSort(int[] array, int left, int right, int depth) {
if (left < right) {
if (depth > 0) { // 还有深度可以并行
int mid = left + (right - left) / 2;
// 创建线程处理左半部分
Thread leftThread = new Thread(() -> parallelMergeSort(array, left, mid, depth - 1));
// 创建线程处理右半部分
Thread rightThread = new Thread(() -> parallelMergeSort(array, mid + 1, right, depth - 1));
leftThread.start();
rightThread.start();
try {
leftThread.join();
rightThread.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
merge(array, left, mid, right);
} else {
// 串行归并排序
mergeSort(array, left, right);
}
}
}
// 可视化当前数组状态
public static void visualizeArray(int[] array, String message) {
System.out.println(message + ": " + Arrays.toString(array));
}
public static void main(String[] args) {
int[] data = {38, 27, 43, 3, 9, 82, 10};
System.out.println("=== 递归归并排序演示 ===");
System.out.println("原始数组: " + Arrays.toString(data));
int[] data1 = Arrays.copyOf(data, data.length);
mergeSort(data1, 0, data1.length - 1);
System.out.println("最终结果: " + Arrays.toString(data1));
System.out.println("\n=== 迭代归并排序演示 ===");
int[] data2 = Arrays.copyOf(data, data.length);
iterativeMergeSort(data2);
System.out.println("最终结果: " + Arrays.toString(data2));
System.out.println("\n=== 并行归并排序演示 ===");
int[] data3 = Arrays.copyOf(data, data.length);
parallelMergeSort(data3, 0, data3.length - 1, 2); // 深度为2的并行
System.out.println("最终结果: " + Arrays.toString(data3));
// 性能测试
System.out.println("\n=== 性能测试 ===");
testPerformance();
}
// 性能测试方法
public static void testPerformance() {
int[] largeData = new int[10000];
for (int i = 0; i < largeData.length; i++) {
largeData[i] = (int) (Math.random() * 10000);
}
long startTime, endTime;
// 测试递归版本
int[] data1 = Arrays.copyOf(largeData, largeData.length);
startTime = System.nanoTime();
mergeSort(data1, 0, data1.length - 1);
endTime = System.nanoTime();
System.out.println("递归版本耗时: " + (endTime - startTime) / 1_000_000 + " ms");
// 测试迭代版本
int[] data2 = Arrays.copyOf(largeData, largeData.length);
startTime = System.nanoTime();
iterativeMergeSort(data2);
endTime = System.nanoTime();
System.out.println("迭代版本耗时: " + (endTime - startTime) / 1_000_000 + " ms");
}
// 归并排序的变体：自然归并排序
public static void naturalMergeSort(int[] array) {
int n = array.length;
boolean sorted = false;
while (!sorted) {
sorted = true;
int left = 0;
while (left < n) {
int mid = findRun(array, left);
if (mid == n - 1) {
if (left == 0) sorted = true;
break;
}
int right = findRun(array, mid + 1);
merge(array, left, mid, right);
left = right + 1;
sorted = false;
}
}
}
// 查找自然有序的run
private static int findRun(int[] array, int start) {
int n = array.length;
if (start >= n - 1) return start;
int i = start;
while (i < n - 1 && array[i] <= array[i + 1]) {
i++;
}
return i;
}
}
代码解析：
-
递归版本：
mergeSort()：递归地将数组分成两半，直到子数组大小为1merge()：合并两个有序子数组，这是算法的核心
-
迭代版本：
- 自底向上地合并子数组，避免递归调用开销
- 更适合处理超大规模数据，避免栈溢出
-
并行版本：
- 利用多线程并行处理左右子数组
- 通过深度控制控制并行粒度
-
变体算法：
- 自然归并排序：利用数组中已有的有序序列
- 原地归并排序：减少空间开销的变体
四、归并排序的性能分析
时间复杂度：
- 最坏情况：O(n log n)
- 最好情况：O(n log n)
- 平均情况：O(n log n)
无论输入数据的分布如何，归并排序都保持稳定的O(n log n)性能。
空间复杂度：
归并排序需要O(n)的额外空间用于临时数组，这是它的主要缺点。
稳定性：
归并排序是稳定的排序算法，因为在合并过程中，当两个元素相等时，总是先取左边子数组的元素。
五、归并排序的优缺点
优点：
- 时间复杂度稳定为O(n log n)，性能可靠
- 稳定排序，保持相等元素的相对顺序
- 适合处理链表数据结构
- 易于并行化处理
- 外部排序的基础算法
缺点：
- 需要O(n)的额外空间
- 递归实现可能导致栈溢出
- 对于小规模数据，常数因子较大
六、归并排序的实际应用
归并排序在以下场景中特别重要：
- 外部排序：处理无法全部装入内存的大规模数据
- 数据库系统：用于查询优化和索引构建
- 编程语言标准库：Java的Arrays.sort()对对象排序使用TimSort（归并排序的变体）
- 大数据处理：MapReduce等分布式计算框架的基础
- 链表排序：归并排序是链表排序的最佳选择
七、归并排序的变体
- 多路归并排序：一次合并多个有序序列，用于外部排序
- 自然归并排序：利用输入数据中已有的有序序列
- TimSort：Java和Python使用的混合排序算法，结合了归并排序和插入排序的优点
- 原地归并排序：减少空间开销的变体，但实现复杂
- 并行归并排序：利用多核处理器并行处理
八、归并排序的数学原理
归并排序的时间复杂度分析基于主定理（Master Theorem）：
T(n) = 2T(n/2) + O(n)
根据主定理，这个递归关系式的解是O(n log n)，因为：
- a = 2（子问题数量）
- b = 2（子问题大小）
- f(n) = O(n)
- 符合情况2：f(n) = Θ(n log_b a) = Θ(n)
九、总结
归并排序不仅是计算机科学中的经典算法，更是分治策略的完美体现。它的发明者约翰·冯·诺依曼以此展示了如何通过递归分解和有序合并来解决复杂问题。
虽然在实际应用中，我们往往使用混合排序算法（如Java的TimSort），但理解归并排序的原理对于掌握算法设计和分析至关重要。它的稳定性、可靠的时间复杂度保证以及易于并行化的特性，使其在大数据处理和外部排序领域不可替代。
归并排序告诉我们：有时候，通过额外的空间开销来换取时间效率的保证和算法的稳定性是值得的。这种空间换时间的设计思想在算法设计中非常常见，归并排序是其最佳范例之一。
浙公网安备 33010602011771号