手摇算法（三重翻转算法）和空间复杂度为o（1）的归并排序

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)。