归并排序的C语言实现与讲解

归并排序是由递归实现的，主要是分而治之的思想，也就是通过将问题分解成多个容易求解的局部性小问题来解开原本的问题的技巧。

另外，归并排序在合并两个已排序数组时，如果遇到了相同的元素，只要保证前半部分数组优先于后半部分数组， 相同元素的顺序就不会颠倒。所以归并排序属于稳定的排序算法。

这里多说一句，分而治之和减而治之是有区别的。

1. 分而治之是将一个问题分成两个或多个子问题（即两个或多个范围较小递归）

solve(left, right){
	int mid = (left + right) / 2;
	return max(solve(left, mid), solve(mid, right));
}

2. 减而治之的意思是将一个问题分解成一个范围较小的递归和一个可以一步求解的平凡子问题，比如求n！

solve(n){
	return n * solve(n - 1);
}

---

废话不多说，先给代码：

#include <bits/stdc++.h>

using namespace std;

#define MAX 500000
#define SENTINEL 2000000000

int L[MAX/2+2], R[MAX/2+2];
int cnt;


void merge(int A[], int left, int mid, int right){

	int n1 = mid - left;
	int n2 = right - mid;

	for (int i = 0; i < n1; i++) L[i] = A[left+i];

	for (int i = 0; i < n2; i++) R[i] = A[mid+i];

	L[n1] = R[n2] = SENTINEL;
	
	int i = 0, j = 0;

	for (int k = left; k < right; k++){
		cnt++;
		if (L[i] <= R[j]){
			A[k] = L[i++];
		} else {
			A[k] = R[j++];
		}
	}
}

void mergeSort(int A[], int left, int right){

	if (left+1 < right){
		int mid = (left+right)/2;
		mergeSort(A, left, mid);
		mergeSort(A, mid, right);
		merge(A, left, mid, right);
	}
}

int main(){

	int A[MAX], n, i;
	cnt = 0;

	cin >> n;
	for (i = 0; i < n; i++) cin >> A[i];

	mergeSort(A, 0, n);

	for (i = 0; i < n; i++){
		if (i) cout << ' ';
		cout << A[i];在这里插入图片描述
	}
	cout << endl;

	cout << cnt << endl;

	return 0;
}

这个是《挑战程序设计竞赛》中的代码，我觉着它设计的相比于B站还有其他地方看到的都妙，别的代码都是将原序列分成单个元素后在合并，而这个最终只会分到三个一组，mergeSort分成（left, mid）和 （mid, right）,也不会有重叠。

奇数情况下

偶数情况下也非常类似：

最后再讲一下merge的过程，就拿奇数情况下最后一次merge来说吧
（即黄底绿字右边标注的4，这一过程）

对照代码方便看

void merge(int A[], int left, int mid, int right){

	int n1 = mid - left;
	int n2 = right - mid;

	for (int i = 0; i < n1; i++) L[i] = A[left+i];

	for (int i = 0; i < n2; i++) R[i] = A[mid+i];

	L[n1] = R[n2] = SENTINEL;
	
	int i = 0, j = 0;

	for (int k = left; k < right; k++){
		cnt++;
		if (L[i] <= R[j]){
			A[k] = L[i++];
		} else {
			A[k] = R[j++];
		}
	}
}

时间复杂度分析：

使用主定理公式：$T(n)=a\ast T(n/b)+\mathrm{O}(f(n))$
其中：

• $T(n)$ 为规模为n的问题需要的时间
• $a$ 为分成a个子问题
• $T(n/b)$ 为每个子问题要用的时间
• $\mathrm{O}(f(n))$ 为任务分解、合并的时间复杂度

主定理就是比较$f(n)$ 和 $n^{lo{g}_a^b}$
如果

• $f(n)<n^{lo{g}_a^b}$，则 $T(n)=\mathrm{O}(n^{lo{g}_a^b})$
• $f(n)$ 与 $n^{lo{g}_a^b}$ 同阶，则 $T(n)=\mathrm{O}(n^{lo{g}_a^b}\ast logn)$
• $f(n)>n^{lo{g}_a^b}$，则 $T(n)=\mathrm{O}(f(n))$

归并排序中，一共分为两个子问题，每个子问题所要用的时间为原问题的一半，分解、合并用的时间复杂度为$\mathrm{O}(n)$

所以 $T(n)=2\ast T(n/2)+\mathrm{O}(n)$

$f(n)=n$
$n^{lo{g}_a^b}=n^{lo{g}_2^2}=n$

$f(n)$ 与 $n^{lo{g}_a^b}$ 同阶, 故归并排序的时间复杂度 $T(n)=\mathrm{O}(n^{lo{g}_a^b}\ast logn)=\mathrm{O}(n^{lo{g}_2^2}\ast logn)=\mathrm{O}(nlogn)$

参考书籍:
[1] （日）渡部有隆. 挑战程序设计竞赛 2 算法和数据结构. 北京：人民邮电出版社, 2016.09.