归并排序（递归与非递归）的实现

摘要：

(1)归并排序几乎以O（NlogN）的时间界实现，是典型的分治算法;

(2)归并排序的基本思路很简单：就是将目标序列分为两个部分，将两个子序列排序好之后，再将它们合并。注意到合并两个已排序的序列只需要O（N）的时间界。

（3）对两个子序列的排序显然也是通过递归的归并排序实现的。

（4）需要注意的一个小细节是，当子序列的元素很少时，继续调用归并排序未必是一件划算的事.因此可以设置一个边界，当元素个数少于这个值时就掉用最简单的插入排序.

【1】合并的过程

合并的过程相对简单，用两个指针指向两个子序列的开始点，然后比较它们的大小.将较小的一个放入新的数组.然后将指向较小元素的指针前移一位。继续这个过程直到某一个指针达到边界.然后将另一个子序列的剩余所有元素都置入新的数组.

【2】注意的细节：如果每一次递归都创建一个新的数组那么将会占用很多的空间.因此合理的做法是在进入递归之前创建两个数组，然后用两个变量Left,Right标志子序列的边界。每一次合并的过程都是把A[Left1]到A[Right1]，A[Left1+1]到A[Right2]合并到B[left1]到B[Right2];

#include "stdafx.h"
#include "malloc.h"
#include "stdlib.h"
#include "string.h"
#define Max 10000000
int Min(int a ,int b)
{
return a < b ? a:b;
}
void Merge(int *A,int *tmp,int Left1,int Right1,int Left2, int Right2)
{
if(Left1==Right1&&Right1==Left2&&Left2==Right2)//只有一个元素不用合并
return;

int point1 = Left1,point2 = Left2,k = Left1;
//int tmp[9];
while(point1 <= Right1 && point2 <= Right2)
{
if(A[point1] <= A[point2])
tmp[Left1++] = A[point1++];
else
tmp[Left1++] = A[point2++];
}
while(point1 <= Right1)
tmp[Left1 ++] = A[point1++];
while(point2 <= Right2)
tmp[Left1++] = A[point2++];
for (Left1 = k;Left1<= Right2;Left1++)
{
A[Left1] = tmp[Left1];
}
}

【2】真正的排序

void Mergesort(int *A,int *tmp,int Left,int Right)
{
int Center;
if(Left == Right)//只有一个元素
return;
Center = (Left + Right)/2;
Mergesort(A,tmp,Left,Center);
Mergesort(A,tmp,Center + 1,Right);
//下面合并
Merge(A,tmp,Left,Center,Center+1,Right);
}

【3】以上的程序都是用递归的办法实现。下面用非递归的办法实现归并排序.

非递归的基本思路

(1)我们应该每次对2^i长度的子序列进行合并。例如最开始对长度为1的相邻子序列进行合并;然后对长度为2的相邻的子序列进行合并。代码如下

void Mergesort2(int *A,int *tmp,int N)
{
//非递归归并
int test[9];

int number = 1;//每次合并个数
int i,Center,end;
while(number <= N-1)
{
for( i = 0;   i + number<= N ; i += number)
{
end = i + number - 1;
Center = (i + end)/2;
Merge(A,tmp,i,Center,Center+1,end);

}
if (i <= N-1)
{
//合并多出的元素
Merge(A,tmp,i-number,i-1,i,N-1);
}
number *= 2;
}
}
void Msort(int A[],int N)
{
int i = 1,cutoff,j;
while(i <= N)
{
i *= 2;
}
cutoff = i - N;
int *B = (int *)malloc(sizeof(int)*i);
int *tmp = (int *)malloc(sizeof(A)*N);
Mergesort2(A,tmp,N);
free(tmp);
}