leetcode打卡4——Median of Two Sorted Arrays

题目

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)).
You may assume nums1 and nums2 cannot be both empty.
大意就是给出两个数组，找出这两个数组的中位数,
example

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

The median is 2.0

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

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

分析

方式一：

看到题目第一感觉就是讲这两个数组从小到大排列放在一个更大的数组中，接着就在这个更大的数据中找中位数，大致代码如下:

 double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int len1 = nums1.size();
        int len2 = nums2.size();
        int i = 0, j = 0;
        vector<int> target;
        while(i < len1 || j < len2) {
            if (i == len1) {
                target.push_back(nums2[j]);
                ++ j;
                continue;
            }
            if (j == len2) {
                target.push_back(nums1[i]);
                ++ i;
                continue;
            }
            if(nums1[i] < nums2[j]) {
                target.push_back(nums1[i]);
                ++ i;
            } 
            else {
                target.push_back(nums2[j]);
                ++ j;
            }
        }
        if (target.size() % 2 == 0) {
            return (double(target[target.size()/2] + target[target.size()/2 -1]))/2;
        }
        else {
            return target[target.size()/2];
        }
    }

看似没什么问题，但该算法的时间复杂度为$O(m+n)$, 而题目要求我们的时间复杂度不得超过$O(log(m+n))$, 所以这种方法不能满足题目的要求，需要寻求另一种解。

方式二:

其实我们不需要将所有的数都加入target数组，因为我们找的是中位数，所以我们只需要将一半的数放入target数组即可:代码

 double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int len1 = nums1.size();
        int len2 = nums2.size();
        vector<int> target;
        int i = 0, j = 0;
        while(target.size() <= (len1 + len2) / 2) {
            if(i < len1 && j == len2 || (i < len1 && nums1[i] < nums2[j])) {
                target.push_back(nums1[i]);
                ++i;
            }
            else {
                target.push_back(nums2[j]);
                ++j;
            }
        }
        if((len1 + len2) % 2 == 0) {
            return (double(target[target.size() - 1] + target[target.size() - 2])) / 2;
        }
        else {
            return target[target.size() - 1];
        }
    }

这种方法和上一种方法相比只要降低了一半的速度，和$O(log(m+n))$还有一些差距，所以还需要寻找更好的方法。

方法三

首先我们两个数组分成两部分

	         left        |        right
	 A[0], A[1], ..., A[i-1]  |  A[i], A[i+1], ..., A[m-1]
  	 B[0], B[1], ..., B[j-1]  |  B[j], B[j+1], ..., B[n-1]

我们只需要保证

1. max(leftt) < max(right)
2. len(left)=len(right) (即 i + j = m - i + n - j)

便可以找到其中位数

$median=(max(left)+min(right))/2$

为确保这两个条件， 我们只需保证

1. i + j = m - i + n -j 或(m-i + n - j + 1)
2. B[j−1]≤A[i] 以及A[i-1] <= B[j]

我们可以使用二分法来实现：

1. 令imin = 0, imax = m。然后在[imin, imax]中进行搜索
2. 令i = (imin + imax) / 2,j = (m + n + 1) / 2 - i (由i + j = m - i + n - j + 1可得)
3. 现在我们有len(left) = len(right)的条件， 我们会遇到是那种情况
   1. 如果B[j-1]<A[i]且A[i-1]<B[j]，就以为这我们找到了i，停止搜索
   2. 如果B[j-1]>A[i]：意味着i太小了，需要将i加大， 令i = i + 1，然后转到步骤2
   3. 如果B[j]<A[i+1], 以为这i太大了，需要减小i， 令 i = i - 1,转到步骤2

代码如下:

 double findMedianSortedArrays(vector<int>& A, vector<int>& B) {
        if (A.size() > B.size()) {
            vector<int> &C = A;
            A = B;
            B = C;
        }
        int m = A.size(), n = B.size();
         int iMin = 0, iMax = A.size(), halfLen = (A.size() + B.size() + 1) / 2;
        while (iMin <= iMax) {
            int i = (iMin + iMax) / 2;
            int j = halfLen - i;
            if (i < iMax && B[j-1] > A[i]){
                iMin = i + 1; // i is too small
            }
            else if (i > iMin && A[i-1] > B[j]) {
                iMax = i - 1; // i is too big
            }
            else { // i is perfect
                int maxLeft = 0;
                if (i == 0) { maxLeft = B[j-1]; }
                else if (j == 0) { maxLeft = A[i-1]; }
                else { maxLeft = A[i-1] > B[j-1] ? A[i-1] : B[j - 1]; }
                if ( (m + n) % 2 == 1 ) { return maxLeft; }

                int minRight = 0;
                if (i == m) { minRight = B[j]; }
                else if (j == n) { minRight = A[i]; }
                else { minRight = A[i] > B[j] ? B[j] : A[i]; }

                return (maxLeft + minRight) / 2.0;
            }
        }
        return 0.0;
    }