LeetCode - Median of Two Sorted Arrays

问题描述：

There are two sorted arrays A and B 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)).

如果这题不要求时间复杂度为O(log (m+n))，就变得简单了，直接二路归并，返回排序之后的中位数即可（复杂度O(n)）。

算法导论上有一个类似的问题：设X[1..n] 和 Y[1..n]为两个数组，每个都包含n个已排好序的数，给出一个求X和Y中所有2n个元素的中位数的、O(lgn)时间的算法。（第二版，9.3-8）

这两个问题是一致的。

对于一个已排序的序列X[1..n]，若n为奇数，则中位数为X[n/2+1]，也是其低中位数；若n为偶数，则中位数为(X[n/2]+X[n/2+1])/2，其低中位数是x[n/2]。

对于X[1..m] 和 Y[1..n] 合并之后的数列Z，其低中位数不在X中，就是Y中。

假设Z的low median在X中，用lm表示，在X[k]位置，则在X中有k个元素小于等于lm，有m-k个元素大于等于lm。

在合并之后的序列Z中，low median的位置 = ceil((m+n)/2)，用mIndex表示。

我们知道，在序列Z中，一定有mIndex 个元素小于等于lm，有(m+n)-mIndex个元素大于等于lm，所以，在Y中，一定有mIndex - k个元素小于等于lm，有n - (mIndex-k)个元素大于等于lm。

因此，我们可以检查：若Y[mIndex-k]<= X[K] <= Y[mIndex-k+1]， 则X[k]是我们要找的low median。边界值发生在k=mIndex, mIndex-k=0, 由于没有Y[0]，只需比较X[k] <= Y[1]即可。

当low median不是X[k]， 则上面的条件就不成立。

若X[k] <Y[mIndex-k] 则说明low median的位置k' > k

若X[k] > Y[mIndex-k+1] 则说明low median的位置k' < k

由以上分析，我们就可以应用binary search去查找在X中是否存在X[k]，使得k<=m && k<mIndex && Y[mIndex-k]<=X[k]<=Y[mIndex-k+1] 或者 k<=m && k=mIndex && X[k] <= Y[1]。如果找到这样的k，这是就是我们要找的low median，否则，一定在Y中，对Y做同样的二分搜索来查找k。

每一个二分查找的时间复杂度为O(lgn)，最多两个二分查找：O(lgn) + O(lgm) = O(lg(m+n)

class Solution {
public:
    double findMedianSortedArrays(int A[], int m, int B[], int n)
    {
    	int array = 1;
    	int k = findMedian(A, m, B, n, 1, m);
    	if(k<0) { k = findMedian(B, n, A, m, 1, n); array = 2; }
    	if((n+m) % 2)
    	{
    		if(array == 1) return A[k-1];
    		else return B[k-1];
    	} else {
    		int medianIndex = (int)ceil((m+n)/2.0);		
    		if(array == 1)
    		{
    			if(k < m && medianIndex-k < n)
    			{
    				if(A[k] <= B[medianIndex-k]) return (A[k-1] + A[k])/2.0;
    				else return (A[k-1] + B[medianIndex-k])/2.0;
    			} else {
    				if(k >= m) return (A[k-1] + B[medianIndex-k])/2.0;
    				else return (A[k-1] + A[k])/2.0;
    			}
    		} else {
    			if(k < n && medianIndex-k < m)
    			{
    				if(B[k] <= A[medianIndex-k]) return (B[k-1] + B[k])/2.0;
    				else return (B[k-1] + A[medianIndex-k])/2.0;
    			} else {
    				if(k >= n) return (B[k-1] + A[medianIndex-k])/2.0;
    				else return (B[k-1] + B[k])/2.0;
    			}
    		}
    	}
    }
    
    int findMedian(int A[], int m, int B[], int n, int low, int high)
    {
    	int medianIndex = (int)ceil((m+n)/2.0);
    	int k = 0;
    	while(low <= high)
    	{
    		k = (low+high)/2;
    		if(k==medianIndex && (n==0 || A[k-1] <= B[medianIndex - k])) 
    		{
    			return k;
    		}
    		else {
    			if(k>medianIndex)
    			{
    				high = k-1;
    				continue;
    			}
    			if(k<medianIndex && (medianIndex-k-1<n && A[k-1]>=B[medianIndex-k-1]) && (medianIndex-k>=n || A[k-1] <= B[medianIndex-k]))
    			{
    				return k;
    			} else {
    				if(medianIndex-k-1>=n || (medianIndex-k-1>=0 && A[k-1]<B[medianIndex-k-1])) { low = k+1; continue; }
    				else { high = k-1; continue; }
    			}
    		}
    	}
    	return -1;
    }
};

不过，这题有更好的解法，把题目抽象成更普遍的一个问题，寻找两个有序序列第k大值问题。

这里有一个清晰明了的解法： http://blog.csdn.net/yutianzuijin/article/details/11499917