排序算法6——图解归并排序及其递归与非递归实现

排序算法1——图解冒泡排序及其实现（三种方法，基于模板及函数指针）
排序算法2——图解简单选择排序及其实现
排序算法3——图解直接插入排序以及折半（二分）插入排序及其实现
排序算法4——图解希尔排序及其实现
排序算法5——图解堆排序及其实现
排序算法6——图解归并排序及其递归与非递归实现
排序算法7——图解快速排序（两种主元选择方法）以及CUTOFF时间测试
排序算法8——图解表排序
排序算法9——图解桶排序及其实现
排序算法10——图解基数排序（次位优先法LSD和主位优先法MSD）
排序算法——比较与总结

---

基本思想

归并排序就是利用归并的思想来实现排序。

原理是：
假设初始序列有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，
然后两两归并，得到n/2（+1）个长度为2（或1）的有序的子序列
再两两归并……
如此重复，知道得到一个长度为n的有序序列为止
这种排序方法称为 2路归并排序

归并排序递归方法实现

下面看递归的实现，思路是
先将数组通过mid拆成两半，首先对左边的子序列进行排序，然后对右边的子序列进行排序
排序结束后，合成到最后的数组中

#include 

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 

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，并且需要在数组和数组之间来回地交换数据
故在实际应用中间，归并排序一般不用来做内排序，而是用来做外排序