归并排序－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++];    }}……

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