归并排序及其拓展问题小和问题

归并排序

整体是递归，左边排好序+右边排好序+merge让整体有序

package class03;

public class Code01_MergeSort {
    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    public static void process(int[] arr, int L, int R) {
        if (L == R) {
            return;
        }
        int mid = L + ((R - L) >> 1);
        process(arr, L, mid);
        process(arr, mid + 1, R);
        merge(arr, L, mid, R);
    }

    public static void merge(int[] arr, int L, int M, int R) {
        int[] help = new int[R - L + 1];
        int i = 0;
        int p1 = L;
        int p2 = M + 1;
        while (p1 <= M && p2 <= R) {
            help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= M) {
            help[i++] = arr[p1++];
        }
        while (p2 <= R) {
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++) {
            arr[L + i] = help[i];
        }
    }

用常见面试题再深入理解一下归并排序的精髓
在一个数组中，一个数左边比它小的数的总和，叫数的小和，所以数的小和累加起来，叫数组小和。求数组小和
例子：[1,3,4,2,5]
1左边比1小的数：没有
3左边比3小的数：1
4左边比4小的数：1，3
2左边比2小的数：1
5左边比5小的数：1，3，4，2
所以数组的小和为1+1+3+1+1+3+4+2=16
分析：首先这道题可以用暴力的方法做两侧for循环依次遍历但是时间复杂度为O(n^2)，但是我们反手一想，归并排序的merge过程就是左边有右边分来merge啊，左边的已经排好序了，右边的也排好序了，那我们右边的数与左边相比右边的数小于左边的数，岂不是把右边的数乘以中点减左边的数加一就是一个小和啊，然后依次执行merge知道排好序。排序的过程顺道找小和，其时间复杂度就是归并排序的时间复杂度O(n*logn)
代码：

package class02;
public class Code06_SmallSum {
    public static int SmallSum(int[] arr){
        if (arr == null || arr.length < 2)
            return 0;
       return process(arr,0,arr.length-1);

    }
    public static int process(int[] arr,int L,int R){
            if (L == R)
                return 0;
            int mid = L + ((R - L) >> 1);
            return process(arr,L,mid)+process(arr,mid+1,R)+merge(arr,L,mid,R);
    }
    public static int merge(int[] arr,int L ,int mid,int R){
        int[] help=new int[R-L+1];
        int p1=L;
        int p2=mid+1;
        int i=0;
        int sum = 0;
        while (p1 <= mid && p2 <= R) {
           sum+= arr[p1] < arr[p2] ? (R - p2 + 1) * arr[p1] : 0;
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1<=mid)
            help[i++]= arr[p1++];
        while (p2<=R)
            help[i++] =arr[p2++];
        for (int j = 0 ; j < help.length;j++)
            arr[L+j]=help[j];

        return sum;
    }
    public static void main(String[] args) {
        int[] arr={1,3,4,2,5,};
       System.out.println(SmallSum(arr));
    }
}

逆序对问题
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
分析：和上面的小和问题一致：
代码：

class Solution {
    public int reversePairs(int[] nums) {
if (nums == null || nums.length < 2) {
                return 0;
            }
          return   process(nums, 0, nums.length - 1);
        }
        public static int process(int[] nums, int L, int R) {
            if (L == R) {
                return 0;
            }
            int mid = L + ((R - L) >> 1);
            return process(nums, L, mid) +  process(nums, mid + 1, R) + merge(nums, L, mid, R);
        }
        public static int merge(int[] arr, int L, int M, int R) {
            int[] help = new int[R - L + 1];
            int count = 0;
            int i = 0;
            int p1 = L;
            int p2 = M + 1;
            while (p1 <= M && p2 <= R) {
                if(arr[p1] <= arr [p2])
                help[i++] = arr[p1++];
                else {
                    help[i++] = arr[p2++];
                    count+= M - p1 + 1 ;
                }
            }
            while (p1 <= M) {
                help[i++] = arr[p1++];
            }
            while (p2 <= R) {
                help[i++] = arr[p2++];
            }
            for (i = 0; i < help.length; i++) {
                arr[L + i] = help[i];
            }
            return count;
        }

    }