数据结构和算法分析之归并排序+小和问题

代码示例：

//归并排序
public class Code_05_MergeSort {

	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;
		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个长度为n的循环，所以时间复杂度为O（n）；
数组长度为n的归并排序所消耗的时间T[n]：调用前面函数将数组划分为两个部分，那每一个部分排序好所花时间为T[n/2]，最后将这两个部分的数组合并成一个有序数组的时间花费为O(n);

公式：T[n]=2T[n/2]+O(n);

最终得出结果为：T[n]=O(nlogn);
因为不管元素在什么情况下都要做出这些步骤，所花销的时间是不变的，所以该算法的最优时间复杂度和最差时间复杂度以及平均复杂度是一致的：O（nlogn）。

小和问题

小和问题
在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个数组
的小和。
例子：
[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

题目解析：

相当于求数组中每一个元素右边有几个比自己大的元素，然后用这个个数乘以自身，对每个元素求得的这样的数相加的到的结果。

使用归并排序来进行求和，在归并的时候把数组分成左右两个，在归并排序进行左右两个数组进行合并排序的时候进行计算。
如果左边数组元素N，小于右边数组元素M，那么从右边数组右指针P到右边数组最后R就有(R-P+1)个N，依次累计相加，最后求出最小和。

代码示例：

public class Code_12_SmallSum {

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