4 寻找两个正序数组的中位数Median of Two Sorted Arrays算法优化

蓝雨原创，转载请注明出处。contact author: qinglanyu_jun@foxmail.com

There are two sorted arrays nums1 and nums2 of size m and n respectively.
Find the meidan of the two sorted arrays. The overall run time complexity should $O(log(m+n))$.
You may assume nums1 and nums2 cannot be both empty.

Example 1:

nums1 = [1, 3]
nums2 = [2]

The median is 2.0

Example 2:

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

Solution 1 合并选择

最容易想到的办法，将两个有序数组进行合并，取最中间的数（合并后奇数个元素）或者最中间两个数（合并后偶数个元素）的平均数即可。其中合并后元素的个数是可以计算的，因此只需要找出合并后的中间元素即可，无需开辟空间存储合并后的数组，最多两个元素的空间用来存储遍历到的最后两个元素。

Code

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        unsigned m = nums1.size(), n = nums2.size();
        unsigned last = (m+n)/2+1;
        unsigned i=0, j=0;
        int meidans[2] = {0};
        unsigned idx = 0;

        while(idx < last)
        {
            if(i<m && j<n)
            {
                meidans[idx&1] = (nums1[i]<=nums2[j]) ? (nums1[i++]) : (nums2[j++]);
            }
            else if(i<m)
            {
                meidans[idx&1] = (nums1[i++]);
            }
            else if(j<n)
            {
                meidans[idx&1] = (nums2[j++]);
            }
            idx ++;
        }

        return (double)(((m+n)&1) ? (meidans[(idx+1)&1]) : ((meidans[0]+meidans[1])/2.0));
    }
};

执行结果：通过
执行用时：16ms，在所有C++提交中击败了84.66%的用户
内存消耗：7.3MB，在所有C++提交中击败了100.00%的用户

然而以上方法的时间复杂度为$O(m+n)$，达不到$O(log(m+n))$的要求。

Solution 2 切分数组

设两有序数组分别为 A = { A [ 0 ] , A [ 1 ] , . . . , A [ m ] } A = \{A[0], A[1], ..., A[m]\} A={A[0],A[1],...,A[m]}和 B = { B [ 0 ] , B [ 1 ] , . . . , B [ n ] } B = \{B[0], B[1], ..., B[n]\} B={B[0],B[1],...,B[n]}，现将$A$和$B$都拆分为左右两部分即：

$A=A_{left}+A_{right}$,
A l e f t = { A [ 0 ] , A [ 1 ] , . . . , A [ i − 1 ] } A_{left} = \{A[0], A[1], ..., A[i-1]\} Aleft​={A[0],A[1],...,A[i−1]}, A r i g h t = { A [ i ] , A [ i + 1 ] , . . . , A [ m ] } A_{right} = \{A[i], A[i+1], ..., A[m]\} Aright​={A[i],A[i+1],...,A[m]}

且

$B=B_{left}+B_{right}$,
B l e f t = { B [ 0 ] , B [ 1 ] , . . . , B [ j − 1 ] } B_{left} = \{B[0], B[1], ..., B[j-1]\} Bleft​={B[0],B[1],...,B[j−1]}, B r i g h t = { B [ j ] , B [ j + 1 ] , . . . , B [ n ] } B_{right} = \{B[j], B[j+1], ..., B[n]\} Bright​={B[j],B[j+1],...,B[n]}

此时，令
$L=A_{left}+B_{left}$
$R=A_{rgiht}+B_{right}$

若$m+n$即$A$和$B$的总长度为偶数时，条件
$size(L)=size(R)$
$max(L)\le min(R)$
满足，那么所寻找的中位数为：
$median=\frac{max(L)+min(R)}{2}$

若$m+n$即$A$和$B$的总长度为奇数时，条件
$size(L)=size(R)+1$
$max(L)\le min(R)$
满足，那么所寻找的中位数为：
$median=max(L)$

又由于上述两组条件等价于以下三个条件：
条件一：
$i+j=(m-i)+(n-j)\Rightarrow i+j=\lfloor \frac{m+n+1}{2}\rfloor$ ，当$m+n$为偶数时
$i+j=(m-i)+(n-j)+1\Rightarrow i+j=\lfloor \frac{m+n+1}{2}\rfloor$，当$m+n$为奇数时

条件二：
假设$m\le n$，且$0\le i\le m,0\le j\le n$,
则对于 $\forall i\in [0,m]$，都有$j=(\lfloor \frac{m+n+1}{2}\rfloor -i)\in [0,n]$

条件三：
$B[j-1]\le A[i]$
$A[i-1]\le B[j]$

为了简化计算，假设$A[i-1],B[j-1],A[i],B[j]$总是存在 。对于 $i=0,i=m,j=0,j=n$这样的临界条件，只需规定$A[-1]=B[-1]=-\infty$ ，$A[m]=B[n]=\infty$即可。 因为其计算并不会影响$L$和$R$中的最大值或最小值产生影响。

最后程序需要计算的是：

在[0,m]中找到i，使得：
     B[j-1]<=A[i]且A[i-1]<=B[j],其中j=(m+n+1)/2-i

同时上述条件也等价于

在[0,m]中找到最大的i,使得：
     A[i-1]<=B[j]，其中j=(m+n+1)2-i

因为：
当 $i$从 $0\sim m$ 递增时， $A[i-1]$递增，$B[j]$递减，所以一定存在一个最大的 $i$满足 $A[i-1]\le B[j]$;
而对于最大的 $i$，有 $i+1$不满足，即代入$i+1$则有$A[i]>B[j-1]$，也就是$B[j-1]<A[i]$。

综上所述，在区间$[0,m]$上对$i$进行二分查找 ，找到最大的满足$A[i-1]\le B[j]$的$i$值，得到了正确的划分有序数组$A$和$B$为有序数组左$L$右$R$两部分的方法。

Code

class Solution {
#define MAX(a, b) ((a)>(b)?(a):(b))
#define MIN(a, b) ((a)<(b)?(a):(b))
public:
	double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
		if (nums1.size() > nums2.size()){
			return findMedianSortedArrays2(nums2, nums1);
		}

		unsigned m = nums1.size(), n = nums2.size();
		int left = 0, right = m;
		int maxL = 0, minR = 0;

		while (left <= right){
			// L = nums1[0, .., i-1], nums2[0, .., j-1]
			// R = nums1[i, .., m-1], nums2[j, .., n-1]
			int i = (left + right) / 2;
			int j = (m + n + 1) / 2 - i;

			int nums_i_1 = (i == 0 ? INT_MIN : nums1[i - 1]);	// nums1[i-1]
			int nums_i = (i == m ? INT_MAX : nums1[i]);			// nums1[i]
			int nums_j_1 = (j == 0 ? INT_MIN : nums2[j - 1]);	// nums2[j-1]
			int nums_j = (j == n ? INT_MAX : nums2[j]);			// nums2[j]

			if (nums_i_1 <= nums_j){
				maxL = MAX(nums_i_1, nums_j_1);
				minR = MIN(nums_i, nums_j);
				left = i + 1;
			}
			else{
				right = i - 1;
			}
		}

		return ((m + n) & 1) == 0 ? (maxL + minR) / 2.0 : maxL;
	}

执行结果：通过
执行用时：16ms，在所有C++提交中击败了84.42%的用户
内存消耗：7.1MB，在所有C++提交中击败了68.98%的用户

以上方法的时间复杂度为$O(logmin(m,n))$，其中$m$和$n$另是数组$nums1$和$nums2$的长度。
空间复杂度为$O(1)$。