聊聊时间复杂度为O(nlogn)的归并排序（上）

归并排序(Merge Sort)

概念

归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

归并

归并操作，也叫归并算法，指的是将两个顺序序列合并成一个顺序序列的方法。

归并排序图解

【思考】为什么要把一个数组先分成一半，然后再进行归并呢？
对于我们的例子，有8个元素，一共可以分成3级，到第3级的时候，每一部分只剩下一个元素了
3？ log2(8) = 3 如果有n个元素，就一共有log2(n)级(向上取整)
这样，我们每一层要处理的个数是一样的，虽然我们把它分成了不同的部分，如果整个归并过程，我们可以用O(n)的时间复杂度来解决的话，那我们就设计出了一个nlogn级别的算法

那我们怎样设计出时间复杂度为O(n)的归并过程呢？

下面请看图解

到此，原理讲完了，废话不多说，怎么用代码实现？
实现归并操作，我得设置三个索引 i，j，k，第一排为归并数组，第二排为设置的辅助数组

直接上代码

//归并排序
template<typename T>
static void mergeSort(T arr[], int n)
{
    __mergeSort(arr, 0, n - 1);
}
//依次划分的过程，直到每一部分只剩一个元素位置
template<typename T>
static void __mergeSort(T arr[], int l, int r)
{
    if(l >= r) //表示每部分只有一个元素，到此划分完毕
    {
        return;
    }
    int middle = (l + r) / 2;
    __mergeSort(arr, l, middle);
    __mergeSort(arr, middle + 1, r);
    //实现归并
   if(arr[middle] > arr[middle + 1])
    {
        __merge(arr, l, middle, r);
    }
}
//实现归并
template<typename T>
static void __merge(T arr[], int l, int m, int r)
{
    //先创建一个等大的临时空间
    T temp[r - l + 1];
    //将归并数组[l, r]复制到临时数组中
    for(int i = l; i <= r; i++)
    {
        temp[i - l] = arr[i];
    }
    //定义三个辅助索引
    int i = l, j = m + 1;
    for(int k = l; k <= r; k++)
    {
        //判断i是否越界
        if(i > m)
        {
            arr[k] = temp[j - l];
            j++;
        }
        else if(j > r)
        {
            arr[k] = temp[i - l];
            i++;
        }
        else if(temp[i - l] < temp[j - l])
        {
            arr[k] = temp[i - l];
            i++;
        }
        else
        {
             arr[k] = temp[j - l];
            j++;
        }
    }
}

然后测试了插入排序和归并排序的性能（用了一个有50000个元素的数组），测试如下

你是不是会觉得归并排序比插入排序性能好太多了，接下来，让我们生成一个拥有50000个元素几乎有序的数组测试两种排序算法的性能

此时，你是不是有很多问号？怎么一个nlogn级别的比n^2的还要慢，不科学？
【解答】那是因为在数组几乎有序时，插入排序的性能接近于O(n)，所以才可能比归并排序优越那么一丢丢
此时，归并排序不服气了，我要优化
【下面进入归并排序的优化环节】

• 当mid索引处的值小于mid+1索引处的值时，就不用进行归并排序，直接已经是排好序的了，所以我们在进行归并排序时添加了一个if语句的判断
  

//实现归并
if(arr[middle] > arr[middle + 1])
{
	__merge(arr, l, middle, r);
}

• 我们还可以对递归退出条件进行优化
  当每一部分的元素小于某一个值时，每一部分几乎有序，我们可以转而采取插入排序

//这里我们把那个值设为15，就是每个部分有15个元素时，就不向下划分，直接采用插入排序系那个每部分排好序，然后直接向上归并
 if(r - l <= 15)
 {
     InsertionSort3(arr, l, r);
     return ;
 }
 //插入排序
template<typename T>
void InsertionSort3(T arr[], int l, int r)
{
    for(int i = l+1; i <= r; i++)
    {
        T temp = arr[i];
        int j;
        for(j = i; j > 0; j--)
        {
            if(arr[j] > temp)
            {
                arr[j] = arr[j - 1];
            }
            else
            {
                break;
            }
        }
        arr[j] = temp;
    }
}

【这是我测试的拥有100000个元素的几乎有序的数组，归并排序笑了】

…………
今天就先写到这里，下一篇还会对归并算法进行进一步优化哦~