排序算法（四）：歸併排序（遞歸寫法與非遞歸寫法）

歸併排序

• 基本思想：

歸併排序是一種採用分治策略，將待排序序列分成若干個不可再分的子序列，先使每個子序列有序，再使子序列段間有序的高效排序算法。

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

分的過程

這種結構和完全二叉樹非常相似，分就是遞歸拆分子序列的過程，遞歸深度爲$\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.歸併排序是一種穩定的排序算法