归并排序－MergeSort

归并排序(Merge Sort)就是利用归并思想对数列进行排序。根据具体的实现，归并排序包括”从上往下”（递归方式）和”从下往上”（非递归方式）2种方式。

1. 从上往下的归并排序：利用了分治的思想。它基本包括3步：
   ① 分解 – 将当前区间一分为二，即求分裂点 mid = (low + high)/2;
   ② 求解 – 递归地对两个子区间a[low…mid] 和 a[mid+1…high]进行归并排序。递归的终结条件是子区间长度为1。
   ③ 合并 – 将已排序的两个子区间a[low…mid]和 a[mid+1…high]归并为一个有序的区间a[low…high]。

2. 从下往上的归并排序：（与从上往下相反）将待排序的数列分成若干个长度为1的子数列，然后将这些数列两两合并；得到若干个长度为2的有序数列，再将这些数列两两合并；得到若干个长度为4的有序数列，再将它们两两合并；直接合并成一个数列为止。这样就得到了我们想要的排序结果。

将两个的有序数列合并成一个有序数列，我们称之为”二路归并排序”。归并排序就是基于二路归并排序的。

下面是归并排序的两种方式：

递归算法－从上往下的方式

//归并排序，递归实现
class Solution{
public:
    //二路归并排序
    //以mid为界限，将[left,mid]和(mid+1,right]合并（前提左右都已经有序了）
    void merge(vector<int> &vec,int left,int mid,int right){
        //外部可以保证mid>left,但是right在某些情况下可能小于或等于mid
        if(right<=mid){
            return;
        }
        vector<int> mres(right-left+1,0);
        int l=left,r=mid+1,k=0;
        while(l<=mid && r<=right){
            if(vec[l]<=vec[r]){
                mres[k++]=vec[l++];
            }else{
                mres[k++]=vec[r++];
            }
        }
        while(l<=mid){
            mres[k++]=vec[l++];
        }
        while(r<=right){
            mres[k++]=vec[r++];
        }

        for(int i=0;i<right-left+1;i++){
            vec[left+i]=mres[i];
        }
    }

    //归并排序，使用了分治的思想
    void mSort(vector<int> &vec,int left,int right){
        if(left<right){
            int mid=(left+right)/2;
            mSort(vec,left,mid);
            mSort(vec,mid+1,right);
            merge(vec,left,mid,right);
        }
    }

    vector<int> &mergeSort(vector<int> &vec){
        mSort(vec,0,vec.size()-1);
        return vec;
    }
};

非递归算法－从下往上

函数merge，还是用上面递归算法中的merge函数
……

vector<int> &mergeSort(vector<int> &vec){
    int length=vec.size();
    int left,mid,right;    //使用对应的left，mid，right
    for(int gap=1;gap<length;gap*=2){
        for(left=0;left<length;left=right+1){
            mid=left+gap-1;
            right=left+2*gap-1;
            if(right>=length){     //处理后面不足2个gap的合并
                right=length-1;
            }
            merge(vec,left,mid,right);
        }
    }
    return vec;
}

归并排序的复杂度和稳定性

时间复杂度

归并排序的时间复杂度是O(N*lgN)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？
归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它的时间复杂度是O(N*lgN)。

空间复杂度

归并排序的时间复杂度是O(N)。

稳定性

归并排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 – 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。
这个稳定性体现在merge函数中的如下代码段：
是写成vec[l]<=vec[r],你肯定不会费力不讨好的写成vec[l]

……

while(l<=mid && r<=right){
    if(vec[l]<=vec[r]){
        mres[k++]=vec[l++];
    }else{
        mres[k++]=vec[r++];
    }
}

……

则这个排序算法是稳定的！