排序方法之归并排序

归并排序（Merge Sort）

归并排序，是创建在归并操作上的一种有效的排序算法。算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。归并排序思路简单，速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列。

1. 基本思想

归并排序是用分治思想，分治模式在每一层递归上有三个步骤：

分解（Divide）：将n个元素分成个含n/2个元素的子序列。

解决（Conquer）：用合并排序法对两个子序列递归的排序。

合并（Combine）：合并两个已排序的子序列已得到排序结果。

2. 实现逻辑

2.1 迭代法

① 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
② 设定两个指针，最初位置分别为两个已经排序序列的起始位置
③ 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
④ 重复步骤③直到某一指针到达序列尾
⑤ 将另一序列剩下的所有元素直接复制到合并序列尾

2.2 递归法

① 将序列每相邻两个数字进行归并操作，形成floor(n/2)个序列，排序后每个序列包含两个元素
② 将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素
③ 重复步骤②，直到所有元素排序完毕

具体的我们以一组无序数列｛14，12，15，13，11，16｝为例分解说明，如下图所示：

上图中首先把一个未排序的序列从中间分割成2部分，再把2部分分成4部分，依次分割下去，直到分割成一个一个的数据，一个一个的数据就是有序的，再把这些数据两两归并到一起使之有序（对于有序数据合并排序是很快的），不停的归并，最后成为一个排好序的序列。

4. 复杂度分析

平均时间复杂度：O(nlogn)——归并排序算法每次将序列折半分组，共需要logn轮，每轮两个有序序列合并是n，因此归并排序算法的时间复杂度是O(nlogn)
最佳时间复杂度：O(n)
最差时间复杂度：O(nlogn)
空间复杂度：O(n)——归并排序算法排序过程中需要额外的一个序列去存储排序后的结果，所占空间是n，因此空间复杂度为O(n)
排序方式：In-place
稳定性：稳定——归并排序算法在排序过程中，相同元素的前后顺序并没有改变，所以归并排序是一种稳定排序算法

不管元素在什么情况下都要做这些步骤，所以花销的时间是不变的，所以该算法的最优时间复杂度和最差时间复杂度及平均时间复杂度都是一样的为：O( nlogn )

归并的空间复杂度就是那个临时的数组和递归时压入栈的数据占用的空间：n + logn；所以空间复杂度为: O(n)。

归并排序算法中，归并最后到底都是相邻元素之间的比较交换，并不会发生相同元素的相对位置发生变化，故是稳定性算法

实现：

这个方法也可以按照二叉树的后续遍历理解，先左子树，后遍历右子树，最后遍历根节点。

void postorder(TreeNode* root) {
        if (root == null) {
            return;
        }
        postorder(root->left);//左
        postorder(root->right);//右
        //对根节点操作
        cout<<root->val<<endl; 
}

先递归左区间，后递归右区间，最后合并两个区间。

#include <iostream>
using namespace std;

// 归并排序（递归版）
void merge_sort_recursive(int arr[], int reg[], int start, int end) {
    if (start >= end)//终止递归条件 ，即当把数组分成一个元素时，有序，返回调用函数处开始合并两个有序素组 
        return;
        
    //分解（Divide）：将n个元素分成个含n/2个元素的子序列。
    int len = end - start, mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;


    merge_sort_recursive(arr, reg, start1, end1);//左子树
    merge_sort_recursive(arr, reg, start2, end2);//右子树


    //对根节点进行处理
    //解决（Conquer）：用合并排序法对两个子序列递归的排序。 
    int k = start;
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    while (start1 <= end1)
        reg[k++] = arr[start1++];
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    //把结果保存到原始的空间中 
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}
void merge_sort(int arr[], const int len) {
    int reg[len];
    merge_sort_recursive(arr, reg, 0, len - 1);
} 

int main(){
    int arr[] = {14,12,15,13,11,16};
    merge_sort(arr,sizeof(arr)/sizeof(arr[0]));
    for(auto v:arr) cout<<v<<" ";
    return 0;
}

对于迭代法可以去看原文