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)).

思路一：合并两个递增数组，然后求中位数

1）线性合并，时间复杂度O(m+n)

public class Solution_2
{
	public static double findMedianSortedArrays(int A[], int B[]) 
	{
		int m = A.length;
		int n = B.length;
		int[] tmp = new int[m + n];
		int i = 0, j = 0, k = 0;
		while(i < m && j < n)
		{
			if(A[i] < B[j])
				tmp[k++] = A[i++];
			else
				tmp[k++] = B[j++];
		}
		while(i < m)
			tmp[k++] = A[i++];
		while(j < n)
			tmp[k++] = B[j++];
		if(k % 2 == 0)
			return (tmp[(k-1)/2] + tmp[k/2]) / 2.0;
		else
			return tmp[k / 2];
    }
	
	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		int[] a = {1,3,5};
		int[] b = {2,4,6,8,10};
		System.out.println(findMedianSortedArrays(a, b));
	}

}

2）通过二分插入将数组B插入数组A中，时间复杂度O（mlogn）

 

思路二：通过求第K最小值来求中位数。

注：

该方法的核心是将原问题转变成一个寻找第k小数的问题（假设两个原序列升序排列），这样中位数实际上是第(m+n)/2小的数。所以只要解决了第k小数的问题，原问题也得以解决。

首先假设数组A和B的元素个数都大于k/2，我们比较A[k/2-1]和B[k/2-1]两个元素，这两个元素分别表示A的第k/2小的元素和B的第k/2小的元素。这两个元素比较共有三种情况：>、<和=。如果A[k/2-1]<B[k/2-1]，这表示A[0]到A[k/2-1]的元素都在A和B合并之后的前k小的元素中。换句话说，A[k/2-1]不可能大于两数组合并之后的第k小值，所以我们可以将其抛弃。

证明也很简单，可以采用反证法。假设A[k/2-1]大于合并之后的第k小值，我们不妨假定其为第（k+1）小值。由于A[k/2-1]小于B[k/2-1]，所以B[k/2-1]至少是第（k+2）小值。但实际上，在A中至多存在k/2-1个元素小于A[k/2-1]，B中也至多存在k/2-1个元素小于A[k/2-1]，所以小于A[k/2-1]的元素个数至多有k/2+ k/2-2，小于k，这与A[k/2-1]是第（k+1）的数矛盾。

当A[k/2-1]>B[k/2-1]时存在类似的结论。

当A[k/2-1]=B[k/2-1]时，我们已经找到了第k小的数，也即这个相等的元素，我们将其记为m。由于在A和B中分别有k/2-1个元素小于m，所以m即是第k小的数。(这里可能有人会有疑问，如果k为奇数，则m不是中位数。这里是进行了理想化考虑，在实际代码中略有不同，是先求k/2，然后利用k-k/2获得另一个数。)

通过上面的分析，我们即可以采用递归的方式实现寻找第k小的数。此外我们还需要考虑几个边界条件：

• 如果A或者B为空，则直接返回B[k-1]或者A[k-1]；
• 如果k为1，我们只需要返回A[0]和B[0]中的较小值；
• 如果A[k/2-1]=B[k/2-1]，返回其中一个；

 

代码：

public class Solution_2_2 {
    public double findMedianSortedArrays(int A[], int B[]) {
        int k = A.length + B.length;
        return k % 2 == 0 ?  (findK(A, 0, A.length - 1, B, 0, B.length - 1, k/2 + 1) + 
        findK(A, 0, A.length - 1, B, 0, B.length - 1, k/2)) / 2
        : findK(A, 0, A.length - 1, B, 0, B.length - 1, k/2 + 1);
    }
    //返回两个数组中第k大的元素。
    public double findK(int a[], int s1, int e1, int b[], int s2, int e2, int k) {
        int m = e1 - s1 + 1;
        int n = e2 - s2 + 1;
        if (m > n) return findK(b, s2, e2, a, s1, e1, k); //a的长度比b的小。
        if (s1 > e1) return b[s2 + k - 1]; 
        if (s2 > e2) return a[s1 + k - 1];
        if (k == 1) return Math.min(a[s1], b[s2]);
        int midA = Math.min(k/2, m), midB = k - midA; 
        //如果a的第midA大的元素比b的第midB大的元素小，
        //那么删掉a的前midA个元素，在剩余的数中找第k-midA大的。
        if (a[s1 + midA - 1] < b[s2 + midB - 1]) 
            return findK(a, s1 + midA, e1, b, s2, e2, k - midA);
        else if (a[s1 + midA - 1] > b[s2 + midB - 1]) 
            return findK(a, s1, e1, b, s2 + midB, e2, k - midB);
        else
            return a[s1 + midA - 1];
    }
}