归并排序(C语言简单实现)

归并排序(C语言简单实现)

归并排序（Merging Sort）利用的就是归并的思想实现的排序方法。原理是：假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[n/2]个长度为2或1的有序子序列；再两两归并，如此重复，直到得到一个长度为n的有序序列为止，这种排序方法称为2路归并排序 。

递归

每次都将序列分一半，比如一个数组有18个数，那么第一次分出1-9和10-18，然后分别对两组继续分半，直到最后剩下一个元素时，即分好了组（此时全都是最小的组，只含一个元素），那么此时只有1个元素是不用排序的，就回到了2个元素为一组的情况，以mid=1那组为例，因为1和2已经排好序了，所以将1和2放一起排序，此时数值7比数值9小，那么这部分排出来的结果就是7,9，然后对mid=2进行排序，因为1-2和3都已经有序了，放一起排序结果就是7,8,9，其他的都是同样的原则，最后将1-9和10-18两大组放一起排序，得到的就是最终的排序结果。

非递归

非递归和递归是反过来的，递归是先分组，一直分到最小的分组(只有1个元素)的时候开始返回进行归并排序，而非递归是反过来的，从最小的开始，也就是只有1个元素开始，然后排序的个数成倍增长(2个，4个，8个)。

递归实现

/* 对顺序表L作归并排序 */
void MergeSort(SqList *L){
	MSort(L->r, L->r, 1, L->length);
}

/* 将SR[s..t]归并排序为TR1[s..t] */
void MSort(int SR[], int TR1[], int s, int t){
	int m;
	int TR2[MAXSIZE+1];
	if(s == t)
		TR1[s] = SR[s];
	else{
		m = (s+t)/2;		//将SR[s..t]平分为SR[s..m]和SR[m+1..t]
		MSort(SR, TR2, s, m);	//递归将SR[s..m]归并为有序的TR2[s..m]
		MSort(SR, TR2, m+1, t);		//递归将SR[m+1..t]归并为有序TR2[m+1..t]
		Merge(TR2, TR1, s, m, t);	//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
	}
}

Megre函数

/* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] */
void Merge(int SR[], int TR[], int i, int m, int n){
	int j, k, l;
	for(j=m+1,k=i;i<=m && j<=n;k++){	//将SR中记录由小到大归并入TR
		if(SR[i] <SR[j])
			TR[k] = SR[i++];
		else
			TR[k] = SR[j++];
	}
	if(i<m){
		for(l=0;l<=m-i;l++)
			TR[k+l] = SR[i+l];		//将剩余的SR[i..m]复制到TR
	}
	if(j<=n){
		for(l=0;l<=n-j;l++)
			TR[k+l] = SR[j+l];		//将剩余的SR[J..N]复制到TR
	}
}

复杂度分析

一趟归并需要将SR[1]-SR[n]中相邻的长度为h的有序序列进行两两归并。并将结果放到TR1[1]-TR1[n]中，这需要将待排序序列中所有记录扫描一遍，耗费O(n)时间，而由完全二叉树的深度可知，整个归并排序需要进行log2(n)次，所以总的时间复杂度为O(nlogn)，而且归并排序最好、最坏、平均时间性能都是这个值。

由于归并排序在归并过程中需要与原始记录序列同样数量的存储空间存放归并结果以及递归时深度为log2(n)的栈空间，所以空间复杂度为O(n+logn)。

综上，归并排序是一种比较占用内存，但效率高而且稳定（用的不是跳跃，而是比较）的算法。

非递归实现

递归让代码清晰，容易理解，但是会造成时间和空间上的性能损耗，下面使用迭代提高性能

/*顺序表归并非递归排序*/
void MergeSort2(SqList *L){
	int* TR = (int*)malloc(L->length*sizeof(int));	//申请额外空间
	int k = 1;
	while(k<L->length){
		MergePass(L->r, TR, k, L->length);
		k = 2*k;		//子序列长度加倍
		MergePass(TR, L->r, k, L->length);	
		k = 2*k;		//子序列长度加倍
	}
}

/* 将SR[]中相邻长度为s的子序列两两归并到TR[] */
void MergePass(int SR[], int TR[], int s, int n){
	int i = 1;
	int j;
	while(i<=n-2*s+1){
		Merge(SR, TR, i, i+s-1, i+2*s-1);		//两两归并
		i = i+2*s;
	}
	if(i<n-s+1)		//归并最后两个序列      
         Merge(SR, TR, i, i+s-1, n);
	else		//若最后只剩下单个子序列
		for(j=i;j<=n;j++)
			TR[j] = SR[j];
}

非递归的迭代方法，避免了递归时深度为log2(n)的栈空间，空间只是用到申请递归临时用的TR数组，因此空间复杂度为O(n)，并且避免递归也在时间性能上有一定的提升。应该说，尽量考虑使用非递归方法。

例子

下面的代码包含了递归和非递归，上面的非递归代码的条件判断比较难看懂，可以看下面示例的代码，其实就是比较符左右数值换了位置而已，但我觉得下面的比较容易看懂。

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10

struct SqList{
	int r[MAXSIZE];
	int length;
};

void Merge(int SR[], int TR[], int i, int mid, int j){
	int m, n, t;
	for(m=i, n=mid+1, t=i;m<=mid && n<=j;t++){
		if(SR[m] < SR[n])
			TR[t] = SR[m++];
		else
			TR[t] = SR[n++];
	}
	//将剩下的值填满 
	while(m <= mid)
		TR[t++] = SR[m++];
	while(n <= j)
		TR[t++] = SR[n++];
}

/* 递归实现================================================================== */ 

void MSort(int SR[], int TR1[], int i, int j){	//SR是源数据，TR1存的是排好序的序列 
	int TR2[MAXSIZE];
	int mid;
	if(i == j)
		TR1[i] = SR[i];	//说明剩一个了
	else{
		mid = (i+j)/2;	//拆成2部分 
		//打印起点和结点以及中值 
		printf("(%d+%d)/2=%d\n",i, j, mid);	 
		MSort(SR, TR2, i, mid);	//递归拆分排序(i到mid部分) 
		MSort(SR, TR2, mid+1, j);	//递归拆分排序(mid到j部分) 
		Merge(TR2, TR1, i, mid, j);	//将两部分进行合并 
	} 
}

/* 对顺序表L作归并排序 */
void MergeSort(SqList* L){
	MSort(L->r, L->r, 0, L->length-1);
}

/* =================================================================================== */ 


/* 非递归实现========================================================================= */

void MergePass(int SR[], int TR[], int i, int n){
	int j = 0;
	while(j+2*i-1<=n){
		Merge(SR, TR, j, j+i-1, j+2*i-1);	//两两归并，传的依次是源数组，目的数组，起点，中点，终点 
		j+=2*i;
	}
	//下面这个判断的意思是mid的值比n(数组最大长度)小，说明剩下的数不够组成一个i的倍数的组合
	//但是mid比n小，说明剩下的还能分成2个组，只是不一样大而已，还是可以排序 
	if(j+i-1<n)	
		Merge(SR, TR, j, j+i-1, n);
	else	//如果mid的值大于等于n，说明剩下的组合不能分成2个组合进行归并排序了，那么直接赋值给目的数组就行了
		while(j<=n)
			TR[j] = SR[j++];
}

void MergeSort2(SqList* L){
	int* TR = (int*)malloc(L->length*sizeof(int));
	int i = 1;
	while(i < L->length){
		MergePass(L->r, TR, i, L->length-1);	//因为是从0开始，所以最后一个数组下标要减去1 
		i*=2;
		MergePass(TR, L->r, i, L->length-1);	
		i*=2;		//子序列长度加倍
	}
}

/* ================================================================================= */


int main(){
	int i;
	SqList* L = (SqList*)malloc(sizeof(SqList));
	L->length = MAXSIZE;
	int a[MAXSIZE] = {5,9,7,8,1,4,3,0,6,2};
	for(i=0;i<MAXSIZE;i++)
		L->r[i] = a[i];
	//递归排序
//	MergeSort(L);
	//非递归排序 
	MergeSort2(L);
	//打印
	for(i=0;i<MAXSIZE;i++)
		printf("%d ",L->r[i]);
	printf("\n");
	return 0;
}

递归结果