排序演算法1——圖解氣泡排序及其實現（三種方法，基於模板及函式指標）
排序演算法2——圖解簡單選擇排序及其實現
排序演算法3——圖解直接插入排序以及折半（二分）插入排序及其實現
排序演算法4——圖解希爾排序及其實現
排序演算法5——圖解堆排序及其實現
排序演算法6——圖解歸併排序及其遞迴與非遞迴實現
排序演算法7——圖解快速排序以及不同CUTOFF的時間測試

基本思想

歸併排序就是利用歸併的思想來實現排序。

原理是：
假設初始序列有n個記錄，則可以看成是n個有序的子序列，每個子序列的長度為1，
然後兩兩歸併，得到n/2（+1）個長度為2（或1）

的有序的子序列
再兩兩歸併……
如此重複，知道得到一個長度為n的有序序列為止
這種排序方法稱為 2路歸併排序

歸併排序遞迴方法實現

下面看遞迴的實現，思路是
先將陣列通過mid拆成兩半，首先對左邊的子序列進行排序，然後對右邊的子序列進行排序
排序結束後，合成到最後的陣列中

#include <iostream>

template<class T>
void Merge(T A[], T tmp[], int L, int R, int R_end) {
	int L_end = R - 1;
	int Num = R_end - L +
 
 1;
	int ptr_tmp = L;

	while (L <= L_end && R <= R_end) {
		if (A[L] <= A[R])
			tmp[ptr_tmp++] = A[L++];
		else
			tmp[ptr_tmp++] = A[R++];
	}

	while (L <= L_end)
		tmp[ptr_tmp++] = A[L++];
	while (R <= R_end)
		tmp[ptr_tmp++] = A[R++];

	for (int i = 0; i < Num; ++i) {
		A[
 
R_end] = tmp[R_end];
		--R_end;
	}
}

template<class T>
void Msort(T A[], T tmp[], int L, int R_end) {
	int mid;
	if (L < R_end) {
		mid = (L + R_end) / 2;
		Msort(A, tmp, L, mid);
		Msort(A, tmp, mid + 1, R_end);
		Merge(A, tmp, L, mid + 1, R_end);
	}
}

template<class T>
void MergeSort(T A[], int N) {
	T *tmp = (T *)malloc(sizeof(T)* N);

	if (tmp != NULL) {
		Msort(A, tmp, 0, N - 1);
		free(tmp);
	}
	else {
		fputs("error!", stderr);
	}
}

template<class T>
void ArrShow(T *A, int N) {
	for (int i = 0; i < N; ++i) {
		std::cout << A[i] << " ";
	}
	puts("\n");
}

int main(int argc, char *argv[]) {
	int test[9] = { 1, 2, 7, 3, 8, 5, 9, 6, 4 };
	ArrShow(test, 9);

	puts("MergeSort : ");
	MergeSort(test, 9);
	ArrShow(test, 9);

	return 0;
}

歸併排序非遞迴方法實現

遞迴排序程式碼上雖然比較清晰，容易理解，
但造成了時間和空間上的效能損耗，那麼可以將遞迴方法轉化為迭代方法來提高效能

可以看到，非遞迴的迭代方法，避免了遞迴時深度為logN的棧空間
空間只是利用到申請歸併臨時用的tmp陣列，因此空間複雜度為O（N）

#include <iostream>

template<class T>
void Merge(T A[], T tmp[], int L, int R, int R_end) {
	int L_end = R - 1;
	int Num = R_end - L + 1;
	int t = L;

	while (L <= L_end && R <= R_end) {
		if (A[L] <= A[R]) {
			tmp[t++] = A[L++];
		}
		else {
			tmp[t++] = A[R++];
		}
	}

	while (L <= L_end) {
		tmp[t++] = A[L++];
	}
	while (R <= R_end) {
		tmp[t++] = A[R++];
	}

	//for (int i = 0; i < Num; ++i) {
	//	A[R_end] = tmp[R_end];
	//	--R_end;
	//}
}

template<class T>
void Merge_pass(T A[], T tmp[], int N, int len) {
	int i;
	for (i = 0; i <= N - 2 * len; i += 2 * len) {
		Merge(A, tmp, i, i + len, i + 2 * len - 1);
	}

	if (i + len < N) {
		Merge(A, tmp, i, i + len, N - 1);
	}
	else {
		for (int j = i; j < N; ++j) {
			tmp[j] = A[j];
		}
	}
}

template<class T>
void MergeSort2(T A[], int N) {
	T *tmp = (T *)malloc(N * sizeof(T));
	if (tmp != NULL) {
		int len = 1;
		while (len < N) {
			Merge_pass(A, tmp, N, len);
			len *= 2;
			Merge_pass(tmp, A, N, len);
			len *= 2;
		}
		free(tmp);
	}
	else {
		fputs("空間不足...", stderr);
	}
}

template<class T>
void ArrShow(T *A, int length) {
	for (int i = 0; i < length; ++i) {
		std::cout << A[i] << " ";
	}
	puts("\n");
}

void ArrShow(int arr[], int N) {
	for (size_t i = 0; i < N; ++i) {
		std::cout << arr[i] << " ";
	}
	puts("\n");
}

int main(int argc, char *argv[]) {
	int test[9] = { 1, 2, 7, 3, 8, 5, 9, 6, 4 };
	ArrShow(test, 9);

	puts("MergeSort : ");
	MergeSort2(test, 9);
	ArrShow(test, 9);

	return 0;
}

它是穩定的排序，最好和最壞以及平均時間複雜度都是O（NlogN）
但它最大的缺點是：需要一個額外的空間tmp，並且需要在陣列和陣列之間來回地交換資料
故在實際應用中間，歸併排序一般不用來做內排序，而是用來做外排序