归并排序的算法应用

对于归并排序的理解，算法递归实现和非递归实现参加之前写的一篇博客：归并排序的递归与非递归实现理解（Java）

在归并排序的过程中，我们可以借助这个过程来完成一些特定的要求。总结如下：

例题一：逆序对（剑指offer原题）

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007。

代码实现：

/**
 * Created by wqh on 2017/7/30.
 */
public class Solution {
    public int InversePairs(int [] array) {
        int count = 0;
        int[] temp = new int[array.length];
        count = Helper(array, 0, array.length-1, temp);
        return count;
    }
    public int Helper(int[] arr, int low, int high, int[] temp){
        if(low == high){
            return 0;
        }
        int mid = (low+high)/2;
        return Helper(arr, low, mid, temp)%1000000007
                +Helper(arr, mid+1, high, temp)%1000000007
                +Merge(arr, low, mid, high, temp)%1000000007;
    }
    public int Merge(int[] arr, int low, int mid, int high, int[] temp){
        int i = mid;  //从最后一个元素开始比较
        int j = high;
        int count = 0;
        int k = 0;
        while(i>=low && j>mid){
            if(arr[i] > arr[j]){  
                temp[k++] = arr[i--];
                count = (count+j-mid)%1000000007;

            }else{
                temp[k++] = arr[j--];
            }
        }
        for(; i >= low || j > mid; i--,j--){
            temp[k++] = i < low ? arr[j] : arr[i];
        }
        for(int m = 0; m < k; m++){ //注意这里是最大值放在临时数组最前面
            arr[high-m] = temp[m];
        }
        return count;
    }
}

例题二：数组最小和（左大神IT名企算法与数据结构题目最优解原题）

数组最小和定义：例如数组a[1,5,7]，在a[0]左边比a[0]小的数的和为0，在a[1]左边比a[0]小的数的和为1，在a[0]左边比a[0]小的数的和为1+5=6，该数组最小和为0+1+6=7。

/**
 * Created by wqh on 2017/7/30.
 */
public class Solution {
    public int getSmallSum(int[] arr){
        if(arr == null || arr.length == 0){
            return 0;
        }
        return func(arr, 0, arr.length-1);
    }
    public int func(int[] arr, int l, int r){
        int count = 0;
        if(l == r)
            return 0;
        int mid = (l+r)/2;
        return func(arr, l, mid) + func(arr, mid+1, r) + merge(arr, l, mid, r);
    }
    public int merge(int[] arr, int left, int mid, int right){
        int[] h = new int[right-left+1];
        int i = left;
        int j = mid+1;
        int count = 0;
        int index = 0;
        while (i <= mid && j <= right){
            if(arr[i] <= arr[j]){
                count += arr[i] * (right-j+1);  //统计个数（j到right均符合条件，i++到下一个）
                h[index++] = arr[i++];
            }else{
                h[index++] = arr[j++];
            }
        }
        for(; i <= mid || j <= right; i++,j++){
            h[index++] = i > mid ? arr[j] : arr[i];
        }
        for(int k = 0; k < h.length; k++){
            arr[left++] = h[k];
        }
        return count;
    }
}