http://blog.csdn.net/ltyqljhwcm/article/details/52155097?locationNum=6&fps=1這篇文章對手搖演算法以及歸併排序有很詳細的講解！！

手搖演算法就是空間複雜度為O(1)，僅僅是依靠交換操作來對字串進行處理。

利用手搖演算法實現歸併排序，主要需要三個變數：

i指向右邊待排序列將要插入的左邊序列的位置；

index指向右邊待排序列的初始位置；

j指向右邊待排序列的末尾位置的後一個位置；

也就是將右邊index-----j-1之間的序列插入到左邊i的前面的位置；也就是將index-------j-1和i-------index-1這兩個資料塊交換位置；

class MergeSort {
public:
    int* mergeSort(int* A, int n) {
        // write code here
        mergeSort(A,0,n-1);
        return A;
    }
    void mergeSort(int* A,int start,int end){
        if(start>=end)
            return;
        int middle=(start+end)/2;
        mergeSort(A,start,middle);
        mergeSort(A,middle+1,end);
        merging(A,start,middle,end);
    }
    void merging(int* A,int start, int middle, int end){
        int i=start;
        int index=middle+1;
        int j=middle+1;
        while(j<=end&&i<j){
        while(A[i]<=A[j]&&i<j){
            i=i+1;
        }
        if(i>=j)
            break;//說明此時已經排序結束
        while(A[j]<A[i]&&j<=end){
            j=j+1;
        }
        reverse(A,index,j-1);
        reverse(A,i,index-1);
        reverse(A,i,j-1);
        i=i+(j-index);
        index=j;
        }  
    }
    void reverse(int* A,int left,int right){
        if(left==right)
            return;
        while(left<=right){
            int temp;
            int* p;
            int* q;
            p=&A[left];
            q=&A[right];
            temp=*p;
            *p=*q;
            *q=temp;
            left=left+1;
            right=right-1;  
        }
    }
};

對於上面的歸併排序來說，空間複雜度為o（1）,而時間複雜度為O(n*logn)--O(n*n*logn)。