排序算法（四）：归并排序（递归写法与非递归写法）

归并排序

• 基本思想：

归并排序是一种采用分治策略，将待排序序列分成若干个不可再分的子序列，先使每个子序列有序，再使子序列段间有序的高效排序算法。

• 排序过程（分治算法）：

分的过程

这种结构和完全二叉树非常相似，分就是递归拆分子序列的过程，递归深度为${\log }_{2}n$

治的过程

合并两个相邻的有序子序列

举个栗子： 将[4、5、7、8] 与 [1、2、3、6] 两个已经有序的子序列合并为最终序列[1、2、3、4、5、6、7、8]

• 代码实现：

C++实现（双vector递归）

#include<iostream>
#include<vector>
using namespace std;

void Merge(vector<int>& array, int begin, int mid, int end){
	vector<int> array1;
	vector<int> array2;
	for (int i = begin; i <= mid; i++){
		array1.push_back(array[i]);
	}
	for (int i = mid + 1; i <= end; i++){
		array2.push_back(array[i]);
	}

	// i,j分别遍历array1和array2
	int i = 0;
	int j = 0;
	// begin是原始数组的开始
	int k = begin;
	while (i < array1.size() && j < array2.size()){
		if (array1[i] <= array2[j]){
			array[k] = array1[i];
			i++;
			k++;
		}
		else{
			array[k] = array2[j];
			j++;
			k++;
		}
	}

	while (i < array1.size()){
		array[k] = array1[i];
		i++;
		k++;
	}
	while (j < array2.size()){
		array[k] = array2[j];
		j++;
		k++;
	}
}

void Mergesort(vector<int>& array, int begin, int end){
	if (end - begin >= 1){
		// 未排序序列中至少有两个数据
		int mid = (begin + end) >> 1;
		// 分
		Mergesort(array, begin, mid);
		Mergesort(array, mid + 1, end);
		// 治
		Merge(array, begin, mid, end);
	}
}

int main(){
	vector<int> array = { 8, 4, 5, 7, 1, 3, 6, 2 };
	Mergesort(array, 0, array.size() - 1);
	for (const auto& e : array){
		cout << e << " ";
	}
	cout << endl;
}

运行结果：1 2 3 4 5 6 7 8

C++实现（单vector递归）

#include<iostream>
#include<vector>
using namespace std;

void Merge(vector<int>& array, int begin, int mid, int end){
	vector<int> array1;
	for (int i = begin; i <= mid; i++){
		array1.push_back(array[i]);
	}

	// i,j分别遍历array1和array2
	int i = 0;
	int j = mid + 1;
	// begin是原始数组的开始
	int k = begin;
	while (i < array1.size() && j <= end){
		if (array1[i] <= array[j]){
			array[k] = array1[i];
			i++;
			k++;
		}
		else{
			array[k] = array[j];
			j++;
			k++;
		}
	}

	while (i < array1.size()){
		array[k] = array1[i];
		i++;
		k++;
	}
}

void Mergesort(vector<int>& array, int begin, int end){
	if (end - begin >= 1){
		// 未排序序列中至少有两个数据
		int mid = (begin + end) >> 1;
		// 分
		Mergesort(array, begin, mid);
		Mergesort(array, mid + 1, end);
		// 治
		Merge(array, begin, mid, end);
	}
}

int main(){
	vector<int> array = { 8, 4, 5, 7, 1, 3, 6, 2 };
	Mergesort(array, 0, array.size() - 1);
	for (const auto& e : array){
		cout << e << " ";
	}
	cout << endl;
}

运行结果：1 2 3 4 5 6 7 8 

C++基于递归归并排序的优化

1. 对小规模子数组使用插入排序

用不同的方法处理小规模问题能改进大多数递归算法的性能，因为递归会使小规模问题中方法调用太过频繁，所以改进对它们的处理方法就能改进整个算法。因为插入排序非常简单， 因此一般来说在小数组上比归并排序更快。

2. 测试待排序序列中左右半边是否已有序

因为a[low…mid]和a[mid…high]本来就是有序的，存在a[low]<a[low+1]…<a[mid]和a[mid+1]<a[mid+2]…< a[high]这两种关系，如果判断出a[mid]<=a[mid+1]的话，我们就认为数组已经是有序的并跳过merge() 方法。

C++实现（非递归）

#include<iostream>
#include<vector>
using namespace std;

void Merge(vector<int>& array, int begin, int mid, int end){
	vector<int> array1;
	vector<int> array2;
	for (int i = begin; i <= mid; i++){
		array1.push_back(array[i]);
	}
	for (int i = mid + 1; i <= end; i++){
		array2.push_back(array[i]);
	}

	// i,j分别遍历array1和array2
	int i = 0;
	int j = 0;
	// begin是原始数组的开始
	int k = begin;
	while (i < array1.size() && j < array2.size()){
		if (array1[i] <= array2[j]){
			array[k] = array1[i];
			i++;
			k++;
		}
		else{
			array[k] = array2[j];
			j++;
			k++;
		}
	}

	while (i < array1.size()){
		array[k] = array1[i];
		i++;
		k++;
	}
	while (j < array2.size()){
		array[k] = array2[j];
		j++;
		k++;
	}
}

void Mergesort(vector<int>& array){
	int N = array.size();
	// 两两归并 每次得到长度为sz的有序序列
	// 终止条件：得到一个长度为N的有序序列
	for (int sz = 1; sz < N; sz *= 2){
		// 控制归并时 每组开始的元素下标
		for (int begin = 0; begin + sz < N; begin += 2 * sz){
			int mid = begin + sz - 1;
			int end = begin + 2 * sz - 1;
			if (end>N - 1){
				end = N - 1;
			}
			Merge(array, begin, mid, end);
		}
	}
}

int main(){
	vector<int> array = { 8, 4, 5, 7, 1, 3, 6, 2 };
	Mergesort(array);
	for (const auto& e : array){
		cout << e << " ";
	}
	cout << endl;
}

运行结果：1 2 3 4 5 6 7 8

• 特性总结：

1.时间复杂度：O（N×logN）
2.空间复杂度：O（N）
3.归并排序是一种稳定的排序算法