剑指offer——数组中的逆序数_____(归并排序)

题目描述

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007 

输入描述:

题目保证输入的数组中没有的相同的数字
数据范围：
	对于%50的数据,size<=10^4
	对于%75的数据,size<=10^5
	对于%100的数据,size<=2*10^5

输入例子:

1,2,3,4,5,6,7,0

输出例子:7

思路：

使用归并排序求逆序数。

归并排序参考资料：http://blog.csdn.net/middlekingt/article/details/8446552

归并排序的实现代码：

public class MergeSort {
	/**
	 * 归并排序
	 * 简介:将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列
	 * 时间复杂度为O(nlogn)
	 * 稳定排序方式
	 * @param nums 待排序数组
	 * @return 输出有序数组
	 */
	public static int[] sort(int[] nums, int low, int high) {
		int mid = (low + high) / 2;
		if (low < high) {
			// 左边
			sort(nums, low, mid);
			// 右边
			sort(nums, mid + 1, high);
			// 左右归并
			merge(nums, low, mid, high);
		}
		return nums;
	}

	public static void merge(int[] nums, int low, int mid, int high) {
		int[] temp = new int[high - low + 1];
		int i = low;// 左指针
		int j = mid + 1;// 右指针
		int k = 0;

		// 把较小的数先移到新数组中
		while (i <= mid && j <= high) {
			if (nums[i] < nums[j]) {
				temp[k++] = nums[i++];
			} else {
				temp[k++] = nums[j++];
			}
		}

		// 把左边剩余的数移入数组
		while (i <= mid) {
			temp[k++] = nums[i++];
		}

		// 把右边边剩余的数移入数组
		while (j <= high) {
			temp[k++] = nums[j++];
		}

		// 把新数组中的数覆盖nums数组
		for (int k2 = 0; k2 < temp.length; k2++) {
			nums[k2 + low] = temp[k2];
		}
	}

	
	// 归并排序的实现
	public static void main(String[] args) {

		int[] nums = { 2, 7, 8, 3, 1, 6, 9, 0, 5, 4 };

		MergeSort.sort(nums, 0, nums.length-1);
		System.out.println(Arrays.toString(nums));
	}
}

Merge_sort(),即归并排序。

实际上归并排序的交换次数就是这个数组的逆序对个数，为什么呢？

我们可以这样考虑：

归并排序是将数列a[l,h]分成两半a[l,mid]和a[mid+1,h]分别进行归并排序，然后再将这两半合并起来。

在合并的过程中（设l<=i<=mid，mid+1<=j<=h），当a[i]<=a[j]时，并不产生逆序数；当a[i]>a[j]时，在

前半部分中比a[i]大的数都比a[j]大，将a[j]放在a[i]前面的话，逆序数要加上mid+1-i。因此，可以在归并

排序中的合并过程中计算逆序数.

本题解题代码：

该解题完全是归并，只需在比较出现后面比前面小的情况时，count+=m-i+1就好。因为后面的都比它大

public class Solution {
    int count = 0;
	public int InversePairs(int [] array) {
		if(array.length==0)return count;
		MergeSort(array, 0, array.length-1);
		return count;
    }
	
	public void MergeSort(int []array,int l,int r){
		if(l<r){
			int m = (l+r)>>1;
			MergeSort(array, l, m);
			MergeSort(array, m+1, r);
			merge(array, l, m, r);
		}
	}
	
	public void merge(int []array,int l,int m,int r){
		int [] temp = new int[r-l+1];
		int i =l,j=m+1,k=0;
		while(i<=m&&j<=r){
			if(array[i]<=array[j])
				temp[k++]=array[i++];
			else {
				temp[k++]=array[j++];
				count+=m-i+1;//这里是算逆序的重要环节。
                count%=1000000007;
			}
		}//while
		
		while(i<=m)
			temp[k++]=array[i++];
		while(j<=r)
			temp[k++]=array[j++];
		//将辅助数组覆盖回原数组。
		for(k=0;k<temp.length;k++)
			array[l+k]=temp[k];
	}
}