归并排序以及拓展

思路

分开数组，加入如下分成两组，创建一个辅助空间，用来合并。用两个指针指向两个数组的下标，比较哪个小，那个小就复制哪个，然后其中一个下标越界，另一个数组剩余都复制下来。

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

public static void mergeSort(int[] arr, int l, int r) {
	if (l == r) {
		return;
	}
	int mid = l + ((r - l) >> 1);
	mergeSort(arr, l, mid);
	mergeSort(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; // 专门给help使用的变量
	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];
	}
}

拓展

这个需要转变思路来求解，求小和做法可以两层循环求得，但是时间复杂度O(n^2)，如果转变思路，使用归并思想。比如上述数组的小和：1+1+3+1+1+3+4+2=16，也可以看右边比自己大的数有多少个，1×4+3×2+4×1+2×1=16；但是在这里merge的时候严格要求必须右边的比左边的大才复制右边的。
左神算法1小时三十分钟处

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

public static int mergeSort(int[] arr, int l, int r) {
	if (l == r) {
		return 0;
	}
	int mid = l + ((r - l) >> 1);
	return mergeSort(arr, l, mid) 
			+ mergeSort(arr, mid + 1, r) 
			+ merge(arr, l, mid, r);
}

public static int 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;
	int res = 0;
	while (p1 <= m && 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 <= 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 res;
}