[LeetCode][4]Median of Two Sorted Arrays解析 -Java实现

Q：

There are two sorted arrays nums1 and nums2 of size m and n respectively. Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

A：

这个题目大致是说给你两个被排序的nums1和nums2数组，找到这两个数组的中位数并且要求O(log(m+n))

O(log(m+n))这个形式很有意思，一般O(log(n))都是分治想法之下的结果（详情可以看我的数据分析与算法结构之后会更新几种常见的O()），那么我们用分治的想法考虑一下，如果有一个数组为x＝m＋n。那么我们假设对x进行二分得到mn，然后再对mn进行二分，直到二分后的数只剩2或者3，返回中位值。对于后半部分来说确实O（log（m+n）），但是如何把x＝m＋n重新排序又是一个问题，我们知道排序算法大多都是O（n^2）的。所以后面使用分治应该是没错的，错在前面不该合并。

我们仔细想想我们分治的目的是什么呢？我们分治的目的是为了在最后数值直有1或者2个的时候很容易的得出中位值。那么这个中位值跟分割前有什么关系呢？这才是解决问题的关键。

根据中位值我们可以得知：

1、两个中位值和分割前中位值没有直接关系，所以不可能用直接计算的方法计算出分割前中位值

2、两个中位值可以表达大小关系

明显1我们不可以用了，只能用2

接下来我们分析两个子序列m和n以及分割前序列x之间中位值的大小关系，得到如下性质：

1、x的中位值Mx肯定在m的中位值Mm和n的中位值Mn之间（假设Mm<Mn对于m的中位值Mm来讲前面肯定有m/2个数字，所以Mm的位置>=m/2,而<=m+n/2,同理Mn的位置肯定是>(n+m)/2)。

2、所以这个肯定在m序列中［m/2，m］的区间内，n序列的［1，n/2］内（Mm<Mn）

针对上面这两个性质，我终于找到了解法，距离我开始解题已经接近一小时了。贼啦难了。。。。－。－iii我得先去吃个饭了，现在都六点多了。等回来继续解。

吃完饭了，继续解析

你是否还记得有一年一个定理叫夹逼定理。跟这个似曾相识吗？没错，我就是这样想的。根据定理2不断的分割，直到m/2=m肯定可以得到我们需要的Mx。顺便说一句，这题真tm难。。。。。居然还要自己推定理。

代码如下（因为是算法题，重点不在解耦上，所以代码有些乱，也没有做解耦操作，代码多也是因为偶奇数的问题）

public class MedianofTwoSortedArrays {
	public static void main(String[] args){
		int[] m = {1,2,3,4,5,6};
		int[] n = {7,8,9,10,11,12};
		System.out.println(method(m, n));
	}

	private static double method(int[] m,int[] n) {
		double Mm = 0;
		double Mn = 0;
		double MmPosition = 0;
		double MnPosition = 0;
		if(m.length==1&&n.length==1){
			if(m[0]==n[0]){
				return m[0];
			}else{
				return ((double)m[0]+(double)n[0])/2;
			}
		}
		if(m.length==1){
			Mm = m[0];
		}else if(n.length==1){
			Mn = n[0];
		}else{
			if(m.length%2==1){//奇数
				MmPosition = (m.length+1)/2-1;
				Mm = m[(int)MmPosition];
			}else{//偶数
				MmPosition = ((double)m.length-1)/2;
				Mm = ((double)m[(int) Math.ceil(MmPosition)]+(double)m[(int) Math.floor(MmPosition)])/2;
			}

			if(n.length%2==1){//奇数
				MnPosition = (n.length+1)/2-1;
				Mn = n[(int)MnPosition];
			}else{//偶数
				MnPosition = ((double)n.length-1)/2;
				Mn = ((double)n[(int) Math.ceil(MnPosition)]+(double)n[(int) Math.floor(MnPosition)])/2;
			}
		}
		if(m.length==1||n.length==1){//数组分裂结束
			if(m.length==1){
				if(Mm<Mn){
					return method(m, Arrays.copyOfRange(n,0, (int) Math.floor(MnPosition)+1));
				}else if (Mm>Mn) {
					return method(Arrays.copyOfRange(n, (int) Math.ceil(MnPosition), n.length),m);
				}else if (Mm==Mn) {
					return Mn;
				}
			}else{
				if(Mm<Mn){
					return method(Arrays.copyOfRange(m, (int) Math.ceil(MmPosition), m.length), n);
				}else if (Mm>Mn) {
					return method(n, Arrays.copyOfRange(m,0, (int) Math.floor(MmPosition)+1));
				}else if (Mm==Mn) {
					return Mn;
				}
			}

		}else {

			if(Mm<Mn){
				return method(Arrays.copyOfRange(m, (int) Math.ceil(MmPosition), m.length), Arrays.copyOfRange(n,0, (int) Math.floor(MnPosition)+1));
			}else if (Mm>Mn) {
				return method(Arrays.copyOfRange(n, (int) Math.ceil(MnPosition), n.length), Arrays.copyOfRange(m,0, (int) Math.floor(MmPosition)+1));
			}else if (Mm==Mn) {
				return Mn;
			}
		}
		return 0;
	}

｝