[排序]归并排序

我们本章来学习一下归并排序的相关内容，归并排序也是一个十分高效的排序，下面我们就具体的学习归并排序。

目录

归并排序的定义

归并排序的基本逻辑

归并递归方法代码实现

归并排序的时间和空间复杂度

归并排序的非递归实现 

---

归并排序的定义

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

我们先看一下归并排序的动态图

归并排序的基本逻辑

我们之前学习链表的时候，做过一道题目，将两个有序链表合并为一个有序链表

而这个思想就和我们的归并排序十分类似，那么我们先看一下，合并有序链表的思想

归并排序必须需要一个tmp开辟的数组来存储归并过程中的数据

通过这个我们可以发现，利用双指针法，依次进行比较，然后进行尾插就可以实现合并链表

这个就是我们归并排序的核心思想，但是这有一个前提，就是两个指针指向的是两个有序的序列

而我们平常的数组并不是有序的，我们看一下逻辑图

以上便是归并排序的基本逻辑，下面我们就要进行代码的具体实现

归并递归方法代码实现

归并排序如果用递归来做的话，还是比较容易的。

我们先完成一个具体框架的搭建，如图所示就是我们归并排序实现的基本框架

 在图中，我们可以看到，我定义了两个函数MergeSort 和_MergeSort,这里解释一下，_MergeSort()函数是MergeSort的子函数，由于MergeSort需要向堆申请空间，我们避免多次申请的情况，就将核心排序逻辑放到子函数中，也就是子函数_MergeSort是具体的归并函数实现

我们现在要对begin和end区间进行排序，那么我们就需要将区间分为左右两个子区间，这里我们不需要单趟排序分割，只需要单纯的从中间开始分

 按照基本的逻辑代码如下所示

以上代码看着没有什么问题，但是其实是有缺陷的，在分组的时候不能这么分

否则会出现栈溢出的问题，会导致死循环

我们来分析一下这个分区间的问题

为什么会出现这个问题呢？

分析图如下

那么，解决方法是什么呢？就是改变分区间的方式   

     我们稍微修改一下代码，即完成了归并排序的递归写法

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void _MergeSort(int* a, int* tmp,int begin, int end)
{
	int mid = (begin + end) / 2;
	//[begin,mid]  [mid +1, end] 如果区间有序就可以进行归并了
	_MergeSort(a, tmp, begin, mid);
	_MergeSort(a, tmp, mid+1, end);
	//归并到tmp
	int begin1 = begin;
	int end1 = mid;
	int begin2 = mid+1;
	int end2 = end; 
	int i = begin;
	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++];
	}
	//拷贝回去
	//这里有一个细节，拷贝的时候并不是从0开始拷贝的，而是从begin的位置进行拷贝
	//拷贝的是从begin到end的区间
	memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	_MergeSort(a, tmp, 0, n - 1);
	free(tmp);
	tmp = NULL;
}

归并排序的时间和空间复杂度

排序一百万个数据

排序一千万个数据 

可以看到归并排序的效率还是很高的

时间复杂度也是比较好算的

归并排序的时间复杂度为O（NlogN）

 

 空间复杂度，由于我们开了一个tmp数组，所以空间复杂度为O（N）

归并排序的非递归实现 

归并排序的非递归实现，大家可能会想着还是和非递归实现快排一样，利用数据结构栈来存储排序的区间，，按照前序遍历的逻辑进行遍历，这个逻辑在分割的时候是完全可以的，但是归并排序，在分割完成后，又会按照后序遍历的逻辑对已分割的区间进行合并，那么这个栈就不好实现，归并排序的非递归实现。

如果必须要用栈来实现非递归的归并排序，也不是不可以，需要再新建一个栈帮助存储合并区间即可。但是还是过于麻烦的

那么我们就用一个更为简单的方法进行实现

我们要知道递归变成非递归有两种方法

1.利用栈来处理

2.直接利用循环处理

我们用循环处理，先来看一下逻辑图

那么下面我们就来进行代码的实现

 

以下即代码的实现 ，但是注意这个代码是有问题的

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	//每组归并数据的数据个数
	int gap = 1;//gap归并一组的数据个数
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)//i代表每次的起始位置
		{
			//[begin1，end1] [begin2,end2]
			int begin1 = i;
			int end1 = i + gap - 1;
			int begin2 = i + gap;
			int end2 = i + 2 * gap - 1;
			int j = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}
			//每组分割排序完要进行归并
			memcpy(a + i, tmp + i, sizeof(end2 - i + 1));
		}
		gap *= 2;
	}
	free(tmp);
	tmp = NULL;
}

 我们的逻辑看似密不透风，但是其实有很大的缺陷，我们假设排序0——9的数据

填上一句打印区间的代码，看一下问题所在

 我们看到排序是错误的，而我们再看一下分割的区间，发现有好几个区间是越界的，那我们就发现了问题所在

导致越界的问题就在于，数组的数据不是gap的倍数，导致了区间越界

我们来分析一下区域越界的情况

        

 这样我们就完善了非递归的归并排序，完整实现了归并排序的非递归

代码如下

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	//每组归并数据的数据个数
	int gap = 1;//gap归并一组的数据个数
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)//i代表每次的起始位置
		{
			//[begin1，end1] [begin2,end2]
			int begin1 = i;
			int end1 = i + gap - 1;
			int begin2 = i + gap;
			int end2 = i + 2 * gap - 1;
			int j = i;
			//第二组越界不存在，这一组就不需要归并
			if (begin2 > n)
			{
				break;
			}
			//第二组的begin2没有越界，end2越界了，需要修改一下，继续归并
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}
			//每组分割排序完要进行归并
			memcpy(a + i, tmp + i, sizeof(end2 - i + 1));
		}
		gap *= 2;
	}
	free(tmp);
	tmp = NULL;
}

归并排序的非递归实现，难点在于对区间的处理，这个点需要我们好好的琢磨琢磨，弄清楚之后归并排序就没那么难理解了。