【数据结构与算法】归并排序实现

【归并排序介绍】

将两个的有序数列合并成一个有序数列，我们称之为"归并"。
归并排序(Merge Sort)就是利用归并思想对数列进行排序。根据具体的实现，归并排序包括"从上往下"和"从下往上"2种方式。

1. 从下往上的归并排序：将待排序的数列分成若干个长度为1的子数列，然后将这些数列两两合并；得到若干个长度为2的有序数列，再将这些数列两两合并；得到若干个长度为4的有序数列，再将它们两两合并；直接合并成一个数列为止。这样就得到了我们想要的排序结果。(参考下面的图片)

2. 从上往下的归并排序：它与"从下往上"在排序上是反方向的。它基本包括3步：
   ① 分解 – 将当前区间一分为二，即求分裂点 mid = (low + high)/2;
   ② 求解 – 递归地对两个子区间a[low…mid] 和 a[mid+1…high]进行归并排序。递归的终结条件是子区间长度为1。
   ③ 合并 – 将已排序的两个子区间a[low…mid]和 a[mid+1…high]归并为一个有序的区间a[low…high]。
   这里是用的从上到下的归并排序

【算法复杂度分析】

归并排序时间复杂度

归并排序的时间复杂度是O(NlgN)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？
归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它的时间复杂度是O(NlgN)。

归并排序稳定性

归并排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 – 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！

【代码实现】

#include <iostream>
#include <vector>

using namespace std;

void MergeSort(vector<int>& vec, int l, int mid, int r) {
	//int*  tmp = new int[r - l + 1];
	int* tmp = (int*)malloc((r - l + 1) * sizeof(int));
	int i = l, j = mid + 1, index = 0;
	while (i <= mid && j <= r) {
		if (vec[i] < vec[j]) {
			tmp[index++] = vec[i++];
		}
		else {
			tmp[index++] = vec[j++];
		}
	}
	while (i <= mid) tmp[index++] = vec[i++];
	while (j <= mid) tmp[index++] = vec[j++];
	for (int i = 0; i < index; i++) {
		vec[l + i] = tmp[i];
	}
	delete []tmp;
}

void Merge_up2down(vector<int>& a, int l, int r) {
	int mid;
	if (l >= r) return;
	mid = (l + r) / 2;
	//先分解为左右两个区间
	Merge_up2down(a, l, mid);   
	Merge_up2down(a, mid + 1, r);
	//后调用MergeSort函数进行排序
	MergeSort(a, l, mid, r);
}

int main() {

	vector<int> a{ 50,60,20,10,40,80,30,70 };
	
	Merge_up2down(a, 0, a.size()-1);

	for (int i = 0; i < a.size(); i++) {
		cout << a[i] << " ";
	}

	return 0;
}