归并排序

归并排序基本原理：对于给定的一组元素，首先将每两个相邻的长度为1的子序进行归并，得到（n/2）个长度为2或1的有序子序列，再将其两两归并，反复执行其过程，直到得到一个有序序列为止。

值得注意的是：在处理合并两个[]的时候，需要创建一个临时数组aux来保存A。还有边界条件的问题：第一个[]中的元素都处理完了，而第二个[]里还有元素或者相反的情况。

数组{49,38,65,97,76,13,27}

初始关键字：[49] [38]  [65] [97]  [76] [13]  [27]

一趟归并后：[38 49] [65 97]  [13 76] [27]

二趟归并后：[38 49 65 97]  [13 27 76]

三趟归并后：[13 27 38 49 65 76 97]

#include <iostream>
#include <algorithm>
#include "string.h"
#include "stdio.h"
#include <vector>
#include <deque>
#include<stack>
using namespace std;

class Sort {
public:
    int* mergeSort(int* A, int n) {
        _mergeSort(A,0,n-1);
        return A;
    }
    void _mergeSort(int* A, int left,int right)
    {
        if(left>=right)
            return;
        int mid=left+(right-left)/2;
        _mergeSort(A,left,mid);
        _mergeSort(A,mid+1,right);
        if(A[mid]>A[mid+1])
        {
            _merge(A,left,mid,right);
        }

    }
    void _merge(int* A,int left,int mid,int right)
    {
        int aux[right-left+1];//创建临时数组，将A中的元素复制到aux中，注意有left个偏移
        for(int i=left;i<=right;i++)
            aux[i-left] = A[i];
        int i=left;
        int j=mid+1;
        for(int k=left;k<=right;k++)
        {
            if(i>mid)//说明[left....mid]这部分已经处理完
            {
                A[k]=aux[j-left];//依次将[j....right]部分存入A中
                j++;
            }
            else if(j>right)
            {
                A[k]=aux[i-left];
                i++;
            }
            else if(aux[i-left]>aux[j-left])//注意：有left个偏移
            {
                A[k]=aux[j-left];
                j++;
            }
            else
            {
                A[k] = aux[i-left];
                i++;
            }
        }
    }
};
int main()
{
    int array[]={3,4,5,1,2,8,7};
    Sort sort;
    int len = sizeof(array)/sizeof(array[0]);
    int* arr = sort.mergeSort(array,len);
    for(int i=0;i<len;i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;
    return 0;
}