数据结构初阶（16）排序算法——归并排序

2.4 归并排序

归并排序（Merge Sort）是基于分治思想的经典排序算法。

++核心逻辑：分而治之------把复杂排序问题拆分成简单子问题解决，再合并子问题的结果++。

联系

链表的合并：两个有序链表l1、l2

创建新链表l3（带头结点），遍历l1、l2，小的尾插到l3。

数组的合并：两个有序数组a1（sz = s1+s2）、a2（sz=s2）

从大下标开始遍历两个数组，大的放到a1的末尾。

时间复杂度：O(N)。

差异

链表可以把结点取下来，可以达到空间复杂度O(1)。

数组a1（sz=s1）、a2（sz=s2），则只能把数据拷贝到新的空间，空间复杂度O(N)。

前提：左区间有序、右区间有序。

怎么让左区间有序、右区间有序呢？

这就需要一种类似于二叉树后序的思想------分治：

先让左区间有序；
再让右区间有序；
最后让整体有序；

基本思想

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

归并排序的基本操作是将已有序的子序列合并，得到完全有序的序列------即先使每个子序列有序，再使子序列段间有序。

若将两个有序表合并成一个有序表，称为二路归并。

归并排序核心步骤：

将无序数据从中间分成两个子序列。

将子序列不断的划分，直到只剩一个数据------该子序列有序了。
拆分的终点：能够进行下一步归并------即子区间有序，只有剩1个数据的时候，才能保证子区间有序；

拆分的终点：只剩一个数据。
归并的起点：只有一个数据。

子序列有序了，就可以开始进行两两合并，直到所有的子序列合并完，排序就完成了。

时间复杂度能够达到O(N*logN)，还算不错。

递归的时候，不是每次递归都去开辟一个子数组（4个数据空间、2个数据空间、......），归并过去再拷贝回来。

而是一次性开辟一个和arr等大的tmp数组，每次归并都在tmp执行，执行完拷贝回arr数组。

如下图所示。

动图演示

下图只展示了从最初一个有序子序列只含有一个数据开始的归并的过程。

没有展示分解的过程。

算法步骤

分解阶段：

将当前待排序数组从中间位置分为两部分。

计算中点： mid = left + （right - left） / 2。

递归地对左右两部分继续分解，直到子数组长度为1。

当前子数组长度为1时，说明该子数组是有序的。

开始从最底层向上回朔。

合并阶段：

将两个已排序的子数组合并为一个有序数组。

使用双指针法比较两个子数组的元素。

较小的元素放入临时数组。

归并完将数据从临时数组拷贝回原数组。

执行下一次归并，直到数组全部有序。

代码实现（递归）

算法思想是利用二叉树后序的思想，实际代码控制的是数组。

逻辑结构和物理结构是分离的。

若是完全按照逻辑结构来实现物理结构------链式二叉树，反而控制起来更加地复杂。

逻辑结构那样去画，是为了更好地帮助我们理解，但是我们没有使用跟逻辑结构一样的物理结构去实现，因为这样反而是更加麻烦的。

（理想很丰满、现实很骨感）

思路（递归实现）：

前提：
申请一个临时数组tmp，因为我们不能在原数组归并，不然会造成覆盖，需要在临时归并，在拷回原数组里。
由于创建了临时数组，我们就需要在创建一个子函数用来专门递归，不然每次调用都会申请空间。

子函数思路：

将序列从中间分成两个区间[left，mid] [mid + 1，right]，调用递归，直到只剩一个数据，一个数据就表示有序了。

在把递归的两个区间进行合并，begin1和end2表示左序列，begin1和end2表示右序列，比较两个序列的值插入到临时数组里，其中肯定会有一个先结束，当其中一个序列拷贝完了就停止拷贝。

把剩下未合并的数据，全部放到tmp数组里。

最后在tmp数组的数据拷到原数组里。

cpp 复制代码

//子函数：用来递归
void _MergeSort(int* a, int begin, int end, int* tmp)
{
	//最小递归子问题------只剩1个数据（有序）
	if (begin == end)
		return;

	int mid = (begin + end) / 2;

	//把传进来的区间从中间分割开，分成两个子区间
    // [begin, mid-1] [mid, end]
	// [begin, mid] [mid+1, end] ------这种划分，在偶数个数据的时候才能平分区间
	//如果这两段区间有序------>那么就可以进行归并------>如何判断有序？
    //------>不判断，不管有没有序，直接分到只剩一个，再一次归并回来，每次归并回来的都有序
    //经典后序
	_MergeSort(a, begin, mid, tmp);            //1.先让左区间有序
	_MergeSort(a, mid + 1, end, tmp);          //2.再让右区间有序

	//两段子区间已经有序，归并，使整个区间有序    //3.最后让整体区间有序
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;         //操作：创建变量保存两个区间的下标
                                              //意义1：不直接操作begin、mid、end
                                              //意义2：增强代码可读性

	//i最好不给0，而是给数组的区间始端，使归并数据的在tmp中的位置与原a中的位置一一对应
	int i = begin;

    //（1）归并到tmp数组
	// 依次比较，取小的尾插到tmp数组------>有一个区间结束，循环就结束------结束条件"或"
    //循环：想的是结束条件，写的是继续条件：用"且"
	while (begin1 <= end1 && begin2 <= end2)   
	{
        //取小的尾插
		if (a[begin1] <= a[begin2])
		{
			tmp[i++] = a[begin1++];    //后置++：先拷贝，再递增
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	//有一个结束了，谁没结束，就继续拷贝
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}

	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}

	//（2）把归并好的数组区间拷贝回原区间
    //因为最后tmp数组空间是要释放的，要保留的是原数组
	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
    //闭区间元素个数= 区间差 + 1
    //不能图方便直接拷贝整个数组，拷贝区间之外的数据拷贝回原数组会覆盖掉原数组的数据
}

void MergeSort(int* a, int n)
{
	//首先开一个临时数组
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}

	//开完数组，就导致当前这个结构无法帮助我们递归------不能每次递归都去开一个数组
	//就需要一个新的负责归并递归的函数，参数：a、tmp、区间

	_MergeSort(a, 0, n - 1, tmp);

	//释放临时数组
	free(tmp);
	tmp = NULL;
}

注意一些细节上的处理。

begin, mid-1\] \[mid, end