超详细注释版：归并排序原理、改进思路及其实现方法（C++实现）

归并排序（Merge Sort）

在排序算法的历史上，归并排序是第一个可以在最坏情况依然保持$O(nlogn)$的运行时间的确定性排序算法，由冯诺依曼与1945年在EDVAC上首次编程实现。

归并排序的思路简单，速度仅次于快速排序，为稳定排序算法。一般用于对总体无序，但是各子项相对有序的数列。在模式上有：分（Divide）、治（Conquer）、合（Combine）三个步骤，主要有迭代法和递归法两种实现方法。适用于数组基本有序、外排序等情况。

本文主要以递归法对归并排序流程进行讨论、实现和分析改进。

策略：分而治之（divide and conquer）

---

二路归并算法原理

• 以上递推和回归的二叉树高度均为为${\log }_{2}8=3$

---

MergeSort框架设计

按照以上流程可以先将列出解题框架，显然用递归是可以实现的。列框架可大致分为3步：

1. 分：将一个数组分为若干个子数组
2. 治：将分解好的子数组两两排序（这里可以将看做：大数组=左数组+右数组），排序算法要考虑一般情况。（sort）
3. 合：将排好序的代码合并。（merge）

按照上述思路先列出框架，由于在合并时需要排好序，所以治、合步骤需要在一个函数中实现，即：

void mergeSort(int* arr, int lo, int hi) { … } //分
void merge(int* arr, int lo, int mid, int hi) { … } //治、合。此函数参数mid非必要

细节设计

①分：以数组中间为分界线，分为左数组和右数组。即左数组和右数组分别调用mergeSort()，重复该过程一直到达递归基。
代码块

void mergeSort(int* arr, int lo, int hi) {  //0 <= lo < hi <= size 
	//递归基
    if (hi - lo < 2) return;

	int mid = (lo + hi) / 2;   //以中点为界限  
	mergeSort(arr, lo, mid);   //左侧子数组数组
	mergeSort(arr, mid, hi);   //右侧子数组

	//2.治、合，进入到这一步时已达到递归深入点，可以看做已经分好组，下面要做的是按照组排序并连接成有序数组
	//注意连接时需要考虑非平凡情况（理解递归的运作方式）
	merge(arr, lo, mid, hi);   //归并为有序数组
}

②治、③合：
（封装在merge函数中）
这里的实现方法有很多个版本，仅选用个人认为可读性最好的一种解释。

考察最一般的情况：在mergeSort()递推完毕，回归未结束程序时，此时左右数组在程序中是分区间标记的。此时在原区间上是无法排序的，就需要开辟一块新的内存空间，此时需要左右数组的指针和新开辟空间的指针，方便维护。
所需创建的变量和向量前后的哨兵如图：

对应代码块：

	int* temp = new int[hi - lo];   //汇总两个子向量的临时区域
	int left_idx = lo;
	int right_idx = mid;            //分别对应左侧和右侧的数组当前位置索引
	int temp_idx = 0;               //临时归并数组的区域索引，最初位置

由于自递归深入点（最内层），每一步都会执行一次merge操作，故在使用merge合并数组后就会使得相对外部的一层left和right成为有序序列，下一步要做的就是实现此操作。
设有序向量：{1,3,7,9} 和 {2,4,6,8}，观察下图合并过程：
每次移动赋值一个元素，temp_idx都会对应向后移动一个单元，直到right和left未经比较的元素耗尽（可作为循环终止条件）。而针对left和right指针同理，每次在绿色框（针对当前的arr[left_idx]和arr[right_idx]两个元素）内比较后，拿出较小的一个数即可，对应的left_idx或right_idx++.

注：若排序方向从小到大，则将代码块中的if条件改为arr[left_idx] < arr[right_idx] 即可，一步到位。因为这里隐含条件是：其中left和right之一耗尽后，剩余的元素都是较小的。

对应代码块：

//情况③（一般情况，蕴含了数组长度left = right的情况）：
	while (left_idx < mid && right_idx < hi) {
		if (arr[left_idx] < arr[right_idx])
			temp[temp_idx++] = arr[left_idx++];  //小的放前面，记得每次执行成功要让对应的指针后移一位
		else
			temp[temp_idx++] = arr[right_idx++];
	}

如果细心一些就会发现，如果left或right之一元素已经耗尽，存在 left_idx < mid 和 right_idx < lo 两种情况，那么这些数就是比较大的数，直接复制到temp即可。

代码块：

//情况①：左侧数组比较元素已耗尽，直接复制
	while (left_idx < mid) {
		temp[temp_idx++] = arr[left_idx++];
	}
//情况②：右侧数组比较情况已耗尽，直接复制
	while (right_idx < hi) {
		temp[temp_idx++] = arr[right_idx++];
	}

注意：一般情况和数组元素耗尽的情况处理是需要有顺序的，应先处理一般情况，再处理left和right耗尽的情况，否则left和right会直接分别复制到temp中去，使得排序失败。
left和right耗尽的两种情况出现顺序无要求。

---

ok，经过一顿操作后temp就是有序的了，最后temp中的数据复制到arr中的对应位置 [lo,hi) 之间，将临时数组temp释放就完成了。

③合：

	for (int i = 0; i < temp_idx; i++) {
		arr[lo + i] = temp[i];
	}

---

整合代码

#include <iostream>
using namespace std;

//MergeSort
void merge(int* arr, int lo, int mid, int hi);       //按照图解思路给出解决步骤

void mergeSort(int* arr, int lo, int hi) {  //0 <= lo < hi <= size 
	//递归基
    if (hi - lo < 2) return;

	//1.分：将数组分为两部分
	int mid = (lo + hi) / 2;   //以中点为界限  
	mergeSort(arr, lo, mid);   //左侧子数组数组
	mergeSort(arr, mid, hi);   //右侧子数组

	//2.治、合，进入到这一步时已达到递归深入点，可以看做已经分好组，下面要做的是按照组排序并连接
	//注意连接时需要考虑非平凡情况（理解递归的运作方式）
	merge(arr, lo, mid, hi);   //归并为有序数组
}

void merge(int* arr, int lo, int mid, int hi) {  //有序向量的归并

	//2.治：数组arr的左端left，注意以处理非平凡情况的思路处理
	int* temp = new int[hi - lo];   //汇总两个子向量的临时区域
	int left_idx = lo;
	int right_idx = mid;            //分别对应左侧和右侧的数组当前位置索引
	int temp_idx = 0;               //临时归并数组的区域索引

	//分情况：数组长度：① left < right  ②.right < left   
	//                ③.左右两数组所比较的元素都未耗尽，则直接比较两数组当前元素归入temp大数组
	//情况③（一般情况，蕴含了数组长度left = right的情况）：
	while (left_idx < mid && right_idx < hi) {
		if (arr[left_idx] < arr[right_idx])
			temp[temp_idx++] = arr[left_idx++];  //小的放前面，记得每次执行成功要让对应的指针后移一位
		else
			temp[temp_idx++] = arr[right_idx++];
	}
	//情况①：左侧数组比较元素已耗尽，直接复制
	while (left_idx < mid) {
		temp[temp_idx++] = arr[left_idx++];
	}
	//情况②：右侧数组比较情况已耗尽，直接复制
	while (right_idx < hi) {
		temp[temp_idx++] = arr[right_idx++];
	}
	//建议：三种情况需要按照顺序处理，最先出现的是一般情况，然后是左侧数组，最后是右侧数组

	//3.合
	for (int i = 0; i < temp_idx; i++) {
		arr[lo + i] = temp[i];
	}

	//所有操作完成后删除左端防止内存泄漏
	delete[] temp;
}

int main() {
    int arr[] = { 5,1,4,6,9,7,1,9,3,10,11,13,12,0 };
	int size = sizeof(arr) / sizeof(arr[0]);
    mergeSort(arr, 0, size );

	cout << "数组大小：" << size << "，排序后：" << endl;
	for (int i = 0; i < size; i++)
		cout << arr[i] << " ";
	cout<<endl;

	return 0;
}

• 以上代码算法是不稳定的.
• 更简洁的实现方法可参考邓公的《数据结构C++》P63页代码2.29.

运行结果：

整合代码：

将情况③while中的if条件判断改为 arr[left_idx] > arr[right_idx] 之后的运行结果（此时归并时右侧元素优先归为合并至左侧，即满足A[i] > A[j] ，且i > j，算法稳定）：

---

稳定性分析与改进

先复习一下稳定性的定义：

若对于向量A中每一对重复元素 A[i] = A[j] （相应的S[ki] = S[kj]），都有i < j 当且仅当 ki < kj ，则称为该算法是稳定算法（stable algorithm）。

为了方便阅读和理解，在归并时使用的代码块（代码注释的 情况③ while部分的if判断条件）会致使相同的、右侧数组中的元素优先合并到temp中，而不是左侧元素，故此算法不稳定。
分析得上述代码的else隐含了=的情况，改进方法是将方法是将情况③的代码块if判断条件 arr[left_idx] < arr[right_idx] 改为如下即可：

if (arr[left_idx] <= arr[right_idx])

本文后面改进的代码会使用稳定的算法.

---

思考与改进

改进点1：

注意到在进入归并函数merge时都要申请一部分空间。这里根据而反复通过new和delete操作申请和释放辅助空间。从实验统计表明，这类操作的实际时间成本大约是常规运算的100倍，故往往成为制约效率提高的瓶颈.

不难想到，我们可以统一申请一块缓冲空间解决空间增长速度过大的问题。即在全局区申请一块足够大的辅助空间（与arr的大小向同即可），其大小可用一个“指针”temp_idx维护，即每次调用merge时可以将temp_idx归零.

• 优势：可以将动态申请的次数降至O(1)，而不再与递归示例的总数O(n)相关。在全局区可以分配给变量的内存空间更大。
• 劣势：会在一定程度上降低代码的规范性和简洁性，代码调试的难度也会有所增加。

改进点2：

我们还可以进一步降低时间成本，可考虑较好的情况：有一段子序列已经排好序。此时我们就没有必要再调用merge算法对其再排序。相应的只需要增加线性时间：
对于规模为n的向量，扫描一遍共增加$2^{{\log }_{2}n}-1$ = $O(n)$
不影响总体时间复杂度$O(nlogn)$.

按照算法流程，在二路归并前，将arr[mid-1]：左侧区间的末元素 与arr[mid]右侧区间的第一个元素比较。若整体有序，则必有 arr[mid-1] ≤ arr[mid]，故可判断并省去merge操作.

此方法即在merge(arr, lo, mid, hi); 前加 if (arr[mid - 1] > arr[mid]) 即可.

改进后代码（稳定）：

#include <iostream>

int arr[] = { 5,1,4,6,9,7,1,9,3,10,11,13,12,0 };
int* temp = new int[sizeof(arr) / sizeof(arr[0])];   //申请在全局区的变量

template <typename T>
void merge(T* arr, int lo, int mid, int hi);

template <typename T>
void mergeSort(T* arr, int lo, int hi) {
	if (hi - lo < 2) return;

	int mid = (lo + hi) >> 1;
	mergeSort<T>(arr, lo, mid);
	mergeSort<T>(arr, mid, hi);
	if (arr[mid - 1] > arr[mid]) merge<T>(arr, lo, mid, hi);    //利用线性时间判断
}

template <typename T>
void merge(T* arr, int lo, int mid, int hi) { //有序向量的归并
	int left_idx = lo, right_idx = mid;

	int temp_idx = 0;   //此时的意义变为：每次归并时使数组指针清零，可视作清空数组

	while (left_idx < mid && right_idx < hi) {
		if (arr[left_idx] <= arr[right_idx])
			temp[temp_idx++] = arr[left_idx++];
		else
			temp[temp_idx++] = arr[right_idx++];
	}

	while (left_idx < mid)
		temp[temp_idx++] = arr[left_idx++];

	while (right_idx < hi) 
		temp[temp_idx++] = arr[right_idx++];

	for (int i = 0; i < temp_idx; i++) 
		arr[lo + i] = temp[i];
}

int main() {
	int size = sizeof(arr) / sizeof(arr[0]);
	mergeSort(arr, 0, size);

	std::cout << "Sorted array:\n";
	for (auto i : arr) std::cout << arr[i] << " ";
	std::cout << std::endl;

	delete[] temp;   //O(1),最后统一释放内存
	return 0;
}

注意：若降序排列在上文的基础之上需要将改进点2处对偶地改为：

if (arr[mid - 1] < arr[mid]) merge(arr, lo, mid, hi);

才能在此基础上保证算法的正确性、稳定性，分析方法同上文。

---

复杂度分析

时间复杂度：

使用递归方程分析法，对长度为n的向量进行归并排序，需递归地对长度为n/2d1两个字向量做归并排序，再花线性时间做一次合并，有以下关系：

$T(1)=O(1)$
$T(n)=2\times T(n/2)+O(n)$

第二个式子两边同除n得
$$T(n)/n=T(n/2)/(n/2)+O(1)$$
令 $S(n)=T(n)/n$
有：

$S(1)=O(1)$
$S(n)=S(n/2)+O(1)$
$=S(n/4)+O(2)$
$=S(n/8)+O(3)$
$......$

$=S(n/2^k)+O(k)$
$=O(logn)$

即有 $T(n)=n\cdot S(n)=O(nlogn)$

空间复杂度：

二叉树的高度为logn，将临时数组temp压入栈的数据占用的空间为n，故将，所以空间复杂度为 ：O(logn+n) = $O(n)$

---

参考资料

《数据结构C++语言版》（第三版）邓俊辉编著

---

反思

从学完MergeSort后独立写了第四遍才运行成功（还是我太菜了），没有写成功的原因：

1.将sort部分和merge部分混起来写，致使每一个功能模块混淆
2.没有列框架，思路不够清晰
3.变量名的可读性差，不利于理顺思路

本文尽可能细化到代码的每一个细节，并使用较多的注释，方便日后以最快的时间回顾，并帮助彻底理解和掌握mergeSort.

限于本人处于数据结构初学阶段，若本文有疏漏之处，欢迎批评指正。