算法 -归并排序

---

归并介绍

1）整体是递归，左边排好序+右边排好序+merge让整体有序
2）让其整体有序的过程里用了排外序方法
3）利用master公式来求解时间复杂度
4）当然可以用非递归实现

归并排序复杂度

T(N) = 2* T(N/2) + O(N^1)

根据master公式可知时间复杂度为O(N* logN)

merge过程需要辅助数组，所以额外空间复杂度为O(N)

归并排序的实质是把比较行为变成了有序信息并传递，比O(N^2)的排序快

为什么归并排序要比冒泡等排序快？

直观的说，我们想想一下冒泡排序每次要把最左的元素从头到尾和最终位置之前的元素进行比较，才得到一个最大值。也就是这个这一遍所有的比较只是为了计算某一个位置的值。
而归并则更有效的利用了比较，每次比较 都可以得到更有用的信息进行局部的排序。

归并排序的实质是把比较行为变成了有序信息并传递，所以比O(N^2)的排序快

例题及变种：

[ 求数组小和-每个数右边有多少个数比他大 ]
[ 求数组中的逆序对数量 每个数右边有多少个数比他小 ]
[ 求数组中的大两倍数对数量 ]
[ 数组用递归和非递归方式排序 ]

eg1：

  public static int getSmallSum(int[] arr) {
        //notice: 边界条件判定
        if (arr==null || arr.length<2){
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }

    private static int process(int[] arr, int l, int r) {
        if (l == r) {
            return 0;
        }
        int m = l + ((r - l) >> 1);

        //notice: sum 不用传入进去。递归想最外一层，sum 等于左右两个子集计算好的结果，再加上左右子集merge过程出现的数据即可
        return process(arr, l, m)
                +
                process(arr, m + 1, r)
                +
                merge(arr, l, m, r);

    }

    private static int merge(int[] arr, int l, int m, int r) {
        int p1 = l;
        int p2 = m + 1;
        int sum = 0;
        int p3 = 0;
        int[] help = new int[r - l + 1];
        while (p1 <= m && p2 <= r) {
            sum = arr[p1] < arr[p2] ? arr[p1] * (r - m + 1) : 0;
            help[p3++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];

        }
        while (p1<=m){
            help[p3++]=arr[p1++];
        }
        while (p2<=r){
            help[p3++]=arr[p2++];
        }
        for (int i = 0; i < help.length; i++) {
            arr[l + i] = help[i++];
        }
        return sum;
    }

本周打卡记录

 第二周进度： 应刷 14 道，实刷 4道
 投入时间 5h+

[ 求数组小和-每个数右边有多少个数比他大 ] 打卡 2022-04-24
[ 求数组中的逆序对数量 每个数右边有多少个数比他小 ] 打卡 2022-04-24
[ 求数组中的大两倍数对数量 ] 打卡 2022-04-24
[ 327.区间和达标的子数组数量 ]
[ 数组用递归和非递归方式排序 ] 打卡 2022-04-22