基于归并排序求小和问题

最近在学左程云大佬的算法课程，发现自己的算法知识真是弱爆了，现在压力有点大，我真是太难了。
最后看完左大视频后，理解了小和问题的原理，就自己手敲了一遍代码。
算法路途艰难险阻，希望我可以不忘初心，砥砺前行！

代码

package smallSum;

import testArrayMethonUnit.TestArrayMethonUnit;

/**
 * @Author: 黄文伟
 * @description: 求小和问题,给定数组，数组中每个元素与左边元素相比，
 *               若左边元素小则计为小和,求出数组的总小和
 * 
 *              例：{3, 1, 2}，
 *              3左边没数，小和0；1左边为3，小和0， 
 *              2左边为3、1，小和1，总的小和为0+0+1=1
 *              
 *              解题：采用归并排序思路解题，递归数组居中划分，
 *                    直至划分到一个数时对左右数组进行外排
 *                  外排过程先判断左边数组是否小于右边，
 *                  若小就将左边数与右边数组长度-下标+1向乘计算出小和，
 *                  再逐层返回递归，最终可得到总的小和。
 * @Date:Created in 9:19 2019/8/9
 */
public class SmallSum {
    // 判断数组是否为空或只有一个数
    public static int smallSum(int[] arrs) {
        if (arrs == null || arrs.length < 2) {
            return 0;
        }
        return mergeSort(arrs, 0, arrs.length-1);
    }

    // 对数组进行递归划分
    public static int mergeSort(int[] arrs, int l, int r) {
        if (l == r) {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        return mergeSort(arrs, l, mid) +
                mergeSort(arrs, mid+1, r) +
                merge(arrs, l, mid, r);
    }

    // 对数组进行左右外排，并返回小和
    public static int merge(int[] arrs, int l, int mid, int r) {
        int[] help =  new int[r - l + 1];
        int i = 0;
        int p1 = l;
        int p2 = mid + 1;
        int res = 0;
        while (p1 <= mid && p2 <= r) {
            // 若左边的数小于右边的数，则计算小和
            res += arrs[p1] < arrs[p2] ? (arrs[p1] * (r - p2 + 1)) : 0;
            // 外排核心
            help[i++] = arrs[p1] < arrs[p2] ? arrs[p1++] : arrs[p2++];
        }
        while (p1 <= mid) {
            // 将剩余数组拷贝进辅助数组
            help[i++] = arrs[p1++];
        }
        while (p2 <= r) {
            // 将剩余数组拷贝进辅助数组
            help[i++] = arrs[p2++];
        }
        // 将排好序的辅助数组遍历回原数组
        for (i = 0; i < help.length; i++) {
            arrs[l + i] = help[i];
        }
        return res;
    }

    public static void main(String[] args) {
        // 随机数组的长度
        int length = 10;
        // 随机数组元素的大小范围（10， 10）
        int size = 10;
        boolean success = true;
        // 测试100次
        for (int a = 0; a < 100; a++) {
            // 自定义的随机生成数组器
            int[] testArr = TestArrayMethonUnit.generateRandomArray(length, size);
            // 拷贝数组
            int[] copyArr = TestArrayMethonUnit.copyArray(testArr);
            
            int testParam = smallSum(testArr);
            int rightParam = rightMethon(copyArr);
            
            if (testParam != rightParam) {
                success = false;
            }
        }
        if (success == true) {
            System.out.println("NICE!!!");
        } else {
            System.out.println("FUCK!!!");
        }
    }

    // 使用暴力写法，结果绝对正确，作用是给算法校验正确性
    public static int rightMethon(int[] arrs) {
        int sum = 0;
        if (arrs == null && arrs.length < 2) {
            return 0;
        }
        for (int i = 0; i < arrs.length; i++) {
            for (int j = 0; j < i; j++) {
                if (arrs[j] < arrs[i]) {
                    sum += arrs[j];
                }
            }
        }
        return sum;
    }
}