课堂例题--归并排序延伸例题--小和问题

小和问题

题目描述

在一个数组中,每一个数左边比当前数小的数累加起来,叫做这个数组的小和,求一个数组的小和

例

• [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

解法一 : 暴力解法

指针i每到一个数,遍历他左边的数,凡是小于他的都加上

public static int smallSum(int[] arr){
    if (arr == null || arr.length < 2){
        return 0;
    }
    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < i; j++) {
            if (arr[j]<arr[i]){
                sum+=arr[j];
            }
        }
    }
    return sum;
}

因为是对指针每一次移动的左边都进行遍历,其实全部都是等差数列,所以时间复杂度就是O(n^2)

解法二 : 归并排序

归并排序在我之前的文章中写过了,传送门归并排序

使用逆向思维,求小和是求该数左边有几个数比这个数小,就加起来,那么反过来不就是看这个数右边有几个数比他大,就累加几个他

那么逆向思维有了,怎么使用归并排序解呢?

在merge的过程中,每一个数求有多少个比这个数大的过程中,是分批的,不遗漏的,不重复的,依此找到的

• 根据以上的详细分析,小和=1的过程(1+1+1+1)+3的过程(3+3)+4的过程(4)+2的过程(2)+5的过程(0) = 16

代码实现如下

	/**
     * 求小和
     * @param arr
     * @return
     */
public static int smallSum2(int[] arr){
    if (arr == null || arr.length < 2){
        return 0;
    }
    return process(arr,0,arr.length-1);
}

	/**
     * 既要排好序,又要求小和
     * @param arr
     * @param left
     * @param right
     * @return
     * process(arr, left, mid)-->左侧排序求小和的数量
     * process(arr,mid+1,right)-->右侧排序求小和的数量
     * merge(arr,left,mid,right)-->左右侧排好序,merge时候产生的数量
     */
public static int process(int[] arr,int left,int right){
    if (left==right){
        return 0;
    }
    int mid = left+(right-left)/2;
    return process(arr, left, mid)
        +process(arr,mid+1,right)
        +merge(arr,left,mid,right);
}

	/**
     *
     * @param arr
     * @param left
     * @param mid
     * @param right
     * @return
     */
public static int merge(int[] arr,int left,int mid,int right){
    int[] temp = new int[right-left+1];
    int i = 0;
    int p1 = left;
    int p2 = mid+1;
    int res = 0;
    while (p1 <= mid && p2 <= right){
        //只有左边小于右边才产生小和数量增加的行为
        //(right-p2+1)当前的右边有多少个数比左边指针所指的数大
        //(right-p2+1)*arr[p1] 个数*左边的数 就是小和增加的量
        res += arr[p1]<arr[p2] ? (right-p2+1)*arr[p1] : 0;
        //和归并排序一样就是剩下的进行拷贝,但是如果等于的话,就先拷贝右组的
        temp[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
    }
    //最终都会有一方越界,谁先越界就直接拷贝剩下的
    //P2先越界
    while (p1 <= mid){
        temp[i++] = arr[p1++];
    }
    //P1先越界
    while (p2 <= right){
        temp[i++] = arr[p2++];
    }
    //把temp[]中的数据拷贝回原来的数组中
    for (i = 0; i < temp.length; i++) {
        arr[left+i] = temp[i];
    }
    return res;
}