归并排序算法

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

    }

    private 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);
    }

    private static void merge(int[] arr, int l, int mid, int r) {
        int[] help = new int[r - l + 1];
        int i = 0;
        int p1 = l;
        int p2 = r;
        while (p1 <= mid && p2 <= r) {
            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 (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
    }

    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int n = arr.length;
        int mergeSize = 1;
        while (mergeSize < n) {
            int l = 0;
            while (l < n) {
                int mid = l + mergeSize - 1;
                if (mid >= n) {
                    break;
                }
                int r = Math.min(mid + mergeSize, n - 1);
                merge(arr, l, mid, r);
                l = r + 1;
            }
            if (mergeSize > n / 2) {
                break;
            }
            mergeSize <<= 1;
        }
    }
	private static void merge(int[] arr, int l, int mid, int r) {
	       int[] help = new int[r - l + 1];
	       int i = 0;
	       int p1 = l;
	       int p2 = r;
	       while (p1 <= mid && p2 <= r) {
	           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 (i = 0; i < help.length; i++) {
	           arr[l + i] = help[i];
	       }
	   }

小和问题：每个数比它小的这个数的左侧的数相加和

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);
    }

private static int merge(int[] arr, int l, int mid, int r) {
   int[] help = new int[r - l + 1];
   int i = 0;
   int p1 = l;
   int p2 = r;
   int res = 0;
   while (p1 <= mid && p2 <= r) {
       res += 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 (i = 0; i < help.length; i++) {
       arr[l + i] = help[i];
   }
   return res;

}

逆序对的个数问题