左神归并排序总结

归并排序

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

递归方法

用如下的例子演示归并的过程：

merge算法就是分别用两个指针p1 、 p2 ，指向左半部分和右半部分，哪个数小就将哪个数存入help数组，然后该指针指向下一个，直到某一指针越界，将另一组数字都存入help数组即可。最后将help数组中的数移回原数组。

以下给出完整代码：

#include <iostream>
void merge(int a[], int l, int m, int r)
{
	int *help = new int[8];
	int i = 0;
	int p1 = l;
	int p2 = m + 1;
	while (p1 <= m && p2 <= r)
	{
		//小于等于时拷贝左侧的数值到help[]
		help[i++] = a[p1] <= a[p2] ? a[p1++] : a[p2++];
	}
	//当某个指针溢出时，将另一侧的数字全部拷贝到help[]中
	//以下两个while循环只会执行一个
	while (p1 <= m)
	{
		help[i++] = a[p1++];
	}
	while (p2 <= r)
	{
		help[i++] = a[p2++];
	}
	for (int j = 0; j < i; j++)
	{
		a[l + j] = help[j];
	}
}

void MergeSort(int  a[], int l, int r)
{
	if (l < r) {
		int mid = l + ((r - l) >> 1);
		MergeSort(a, l, mid);
		MergeSort(a, mid + 1, r);
		merge(a, l, mid, r);
	}	
}

int main()
{
	int a[] = { 5,6,4,2,9,8,7,3,1 };
	int i = 0, j = 8;
	MergeSort(a, i, j);
	for (int i = 0; i <= 8; i++)
		std::cout << a[i] << " ";
}

非递归方法

非递归方法的归并排序就是通过两两合并，排序后再合并，最终获得了一个有序的数组。观察它的形状，会发现他像一个倒置的完全二叉树，通常涉及到完全二叉树的排序算法效率一般都不会低的。

以下是非递归的核心过程：

//待排序的a[],和数组中数字的个数n
void MergeSort(int *a,int n){
	int *help = new int[n];
	int k=1;
	while(k<n){
		MergePass(a,help,k,n);
		k=2*k;//子序列加长倍数
		MergePass(help,a,k,n);
		k=2*k;
	}
}

void MergePass(int a[],int help[],int s,int n){
	int i=1;
	int j;
	//因为是两两归并，s=1,如果n-2*s+1=8,是从1到8循环，而不是9，最终的9记录定会剩下来
	while(i<=n-2*s+1)
	{
		Merge(a,help,i+s-1,i+2*s-1); //两两归并
		i=i+2*s; 
	}
	if(i<n-s+1)
		Merge(a,help,i,i+s-1,n);
	else
		for(j=i;j<=n;j++)
			a[j]=help[j];
}
//将有序的help[i,,,m]和help[m+1,,,n]归并为有序的a[i,,,,n]
void Merge(int help[],int a[],int i,int m,int n)
{
	int j,k,l;
	//将help中记录由小到大归并入a[]
	for(j=m+1,k=i;i<=m&&j<=n;k++)
	{
		if(help[i]<help[j]
		a[k]=help[i++];
		else
			a[k]=help[j++];
	}
	if(i<=m)
	{
		for(l=0;l<=m-i;l++) //剩余的help[i,,,m]复制到a[]
			a[k+1]=help[i+l];
	}
	if(j<=n)
	{
		for(l=0;l<=n-j;l++)//剩余的help[j,,,n]复制到a[]
			a[k+1]=help[j+l];
	}
}

时间复杂度：

master 公式：T(N)=aT(N/b)+O(N^d)

1. log(b,a)<d 时间复杂度为O(N^d)
2. log(b,a)>d 时间复杂度为O(N^log(b,a))
3. log(b,a)=d 时间复杂度为O(N^d*log N)

b是递归的规模，O(N^d)是除了递归部分其他程序的复杂度
这个递归每次都取中值，所以b=2，有两次递归所以a=2

归并排序：T(N)=2T(N/2)+O(N)

a=2,b=2,d=1

log(b,a)==d
时间复杂度为 O(N*logN)