摘要：
(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);
}