归并排序：分而治之的艺术（手把手教你写高效排序算法）

最新推荐文章于 2026-01-05 22:36:07 发布

原创最新推荐文章于 2026-01-05 22:36:07 发布 · 893 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法 #算法

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

一、为什么说归并排序是程序员的必修课？

在排序算法的世界里，归并排序就像个低调的扫地僧（看似平平无奇实则功力深厚）！相比冒泡排序的憨厚、快速排序的锋芒毕露，它用独特的分治思想实现了O(n log n)的时间复杂度，堪称处理海量数据的秘密武器！

三大必学理由：

面试高频考点（LeetCode至少30道相关题目）
大数据处理的底层核心（Hadoop/Spark都在用）
理解递归思想的绝佳案例

二、庖丁解牛：拆解归并排序四部曲

2.1 分治思想：化整为零的智慧

想象你要整理一副扑克牌：把牌堆分成两半 → 分别排序 → 合并成有序序列。这就是归并排序的分治三连：

分解：将数组二分为左右子序列
解决：递归排序子序列
合并：将有序子序列合并

// 分治模板代码示例
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);       // 合并操作
    }
}

2.2 合并操作：双指针的华尔兹

（划重点）合并才是归并排序的灵魂所在！来看这个神操作：

创建临时数组存放合并结果
双指针分别指向两个子序列头部
比较-选择-移动三部曲循环执行

void merge(int arr[], int left, int mid, int right) {
    int temp[right-left+1];  // 临时数组
    int i = left, j = mid+1, k = 0;
    
    // 双指针交替前进
    while(i <= mid && j <= right) {
        temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];
    }
    
    // 处理剩余元素
    while(i <= mid) temp[k++] = arr[i++];
    while(j <= right) temp[k++] = arr[j++];
    
    // 写回原数组
    for(int p=0; p<k; p++) {
        arr[left+p] = temp[p];
    }
}

2.3 递归终止条件：别让程序无限套娃

当子数组长度≤1时立即返回！这是避免死循环的关键：

if (left >= right) return;  // 递归出口

三、复杂度分析（超级重要！）

指标	时间复杂度	空间复杂度
最好情况	O(n log n)	O(n)
最坏情况	O(n log n)	O(n)
平均情况	O(n log n)	O(n)

划重点：稳定的O(n log n)让它吊打冒泡/插入排序（O(n²)），但需要额外O(n)空间（内存换时间的典型）！

四、六大优化技巧（实战干货）

内存预分配：提前分配好临时数组，避免反复创建
插入排序混合：当子数组长度<15时改用插入排序
并行化处理：左右子数组的排序可以并行执行
哨兵技巧：在子数组末尾设置MAX值简化判断
非递归实现：用迭代代替递归防止栈溢出
三路归并：把数组分成三部分处理（适合海量数据）

// 优化版非递归实现
void mergeSortIterative(int arr[], int n) {
    for(int curr_size=1; curr_size<=n; curr_size*=2) {
        for(int left=0; left<n; left+=2*curr_size) {
            int mid = min(left+curr_size-1, n-1);
            int right = min(left+2*curr_size-1, n-1);
            merge(arr, left, mid, right);
        }
    }
}

五、应用场景大盘点

大数据排序：Hadoop的MapReduce底层就是归并排序
链表排序：合并操作只需修改指针，效率极高
外部排序：处理超出内存的数据文件
稳定排序需求：相同元素保持原始顺序
逆序对统计：稍加改造就能高效计算逆序对数量

举个栗子：MySQL的ORDER BY操作，当数据量超过内存限制时，就会使用归并排序进行外部排序！

六、常见坑点预警（血泪教训）

数组越界：mid计算要使用left + (right - left)/2写法
临时数组长度：必须是right - left + 1
剩余元素处理：合并后别忘记把剩余元素拷贝进去
递归深度限制：对超大数组可能引发栈溢出
写回原数组时：起始位置应该是left而不是0

七、手撕代码实战

让我们用归并排序解决LeetCode 912题（排序数组）：

int* sortArray(int* nums, int numsSize, int* returnSize){
    *returnSize = numsSize;
    int* temp = (int*)malloc(sizeof(int)*numsSize);  // 预分配内存
    mergeSort(nums, 0, numsSize-1, temp);
    free(temp);
    return nums;
}

void mergeSort(int* arr, int left, int right, int* temp){
    if(left >= right) return;
    int mid = left + (right - left)/2;
    mergeSort(arr, left, mid, temp);
    mergeSort(arr, mid+1, right, temp);
    
    // 合并操作优化版
    int i = left, j = mid+1, k = 0;
    while(i <= mid && j <= right){
        temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];
    }
    while(i <= mid) temp[k++] = arr[i++];
    while(j <= right) temp[k++] = arr[j++];
    
    // 内存拷贝优化
    memcpy(arr+left, temp, sizeof(int)*k);
}