排序算法:归并排序

什么是归并排序？

  归并排序主要是将多个已排好的子数组合成一个排好序的数组。为了使这些子数组排好序，该算法了采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
  它是计算机中使用的早期排序算法之一，是由John von Neumann提出来的：
  动态效果示意图：

分而治之：

 1、分阶段：

 2、治阶段：
  再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。

参考例子：剑指offer面试题35——数组中的逆序对

#include<iostream>
#include<vector>
using namespace std;
//采用归并排序算法
//逆序对的总数 = 左边数组中的逆序对的数量 + 右边数组中逆序对的数量 + 左右结合成新的顺序数组时中出现的逆序对的数量
class Solution{
    public:
        int InversePairs(vector<int> data){
            if(data.size()==0){
                return 0;
            }
            //排序的辅助数组
            vector<int> copy; // 把传进来的数组复制到这个数组中
            for(int i=0;i < data.size();++i){
                copy.push_back(data[i]);
            }
            return InversePairsCore(data,copy,0,data.size()-1) % 1000000007;
        }
        long InversePairsCore(vector<int> &data, vector<int> &copy,int begin, int end){
            if(begin == end){
                copy[begin] == data[end];
                return 0;
            }
            // 求中点
            int mid = (end + begin) >> 1;
            // 使data右半段有序，并返回右半段逆序对的数目
            long leftCount = InversePairsCore(copy, data, begin, mid);
            // 使data右半段有序，并返回右半段逆序对的数目
            long rigthCount = InversePairsCore(copy, data, mid +1, end);
            int i = mid; // j初始化为前半段最后一个数字的下标
            int j = end; // j初始化为后半段最后一个数字的下标
            int indexcopy = end; // 辅助数组复制的数组的最后一个数字的下标
            long count = 0; // 计数，逆序对的个数，注意类型
            while(i >=begin && j>=mid+1){ //如果相等则表示只剩一个元素了
                if(data[i] > data[j]){ //如果左指针大于右指针

                    copy[indexcopy--] = data[i--]; //往右放做降序排序
                    count += j-mid; //逆序数就是P2加它左边的数=2
                }
                else{
                    copy[indexcopy--] = data[j--]; //往右放做降序排序
                }
            }
            for(;i >=begin;--i){
                copy[indexcopy--] = data[i];
            }
            for(;j >= mid+1; --j){
                copy[indexcopy--] = data[j];
            }
            return leftCount + rigthCount + count;
        }
};
int main(){
    int array1[] = {7,5,6,4};
    vector<int> array2 = {};
    for(int i=0;i<4;i++){
        array2.push_back(array1[i]);
    }
    Solution T;
    int count = T.InversePairs(array2);
    cout<<"The result is:"<<count<<endl;
}

算法分析

三、算法分析

1、归并排序算法的性能

其中，log2n为以2为底，n的对数。

2、时间复杂度
  归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它的时间复杂度是O(n*log2n)。

3、空间复杂度
  由前面的算法说明可知，算法处理过程中，需要一个大小为n的临时存储空间用以保存合并序列。

4、算法稳定性
  在归并排序中，相等的元素的顺序不会改变，所以它是稳定的算法。

5、归并排序和堆排序、快速排序的比较
  若从空间复杂度来考虑：首选堆排序，其次是快速排序，最后是归并排序。
  若从稳定性来考虑，应选取归并排序，因为堆排序和快速排序都是不稳定的。
  若从平均情况下的排序速度考虑，应该选择快速排序。

 如果使用迭代来取代递归，或者对数组的一小部分使用插入排序（快速排序中就使用这种方式），归并排序的效率将更高。然而，归并排序有一个严重的缺点：合并数组需要额外的存储空间，对于大量的数据来说，这样的需求会是一个难以忍受的缺点。

参考文章：
https://cuijiahua.com/blog/2018/01/algorithm_7.html.