[LeetCode] 4. Median of Two Sorted Arrays

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

解析

由于时间复杂度规定为O(log (m+n))，所以想到二分查找。两个数组长度为(m+n)，所以分别查找（m+n+1）/2和（m+n+2）/2两个位置的数之和除以2就能得到中位数。

递归

现在定义一个在两个排序数组中查找第k个数的递归函数，分别用i和j表示nums1和nums2的当前下标，初始为0.
对k进行二分，分别在nums1和nums2中找第k/2个数。
当i>=m时，只需要找nums2中j后k个数；
当j>=n时，只需要找nums1中i后k个数；
当k==1时，只需要找i和j的较小值。
如果当前下标往后不存在k/2个数，则另一个数组往后找k/2个数
比较两个数组第k/2个数mid1和mid2的大小，如果mid1<mid2，则nums1往后找k/2个数，否则nums2往后找k/2个数
k自减k/2;

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m=nums1.size(),n=nums2.size();
        int left = (n+m+1)>>1, right = (n+m+2)>>1;
        return (findKth(nums1,0,nums2,0,left)+findKth(nums1,0,nums2,0,right))/2.0;
    }
    
    int findKth(vector<int>& nums1, int i, vector<int>& nums2, int j, int k){
        if(i >= nums1.size()) return nums2[j+k-1];
        if(j >= nums2.size()) return nums1[i+k-1];
        if(k == 1) return min(nums1[i],nums2[j]);
        int mid1 = i + k/2 -1 < nums1.size() ? nums1[i + k/2 -1] : INT_MAX;
        int mid2 = j + k/2 -1 < nums2.size() ? nums2[j + k/2 -1] : INT_MAX;
        if(mid1 < mid2)
            return findKth(nums1,i+k/2,nums2,j,k-k/2);
        else
            return findKth(nums1,i,nums2,j+k/2,k-k/2);
    }
};

迭代

贴出参考代码，还不理解。。。。

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        if (m < n) return findMedianSortedArrays(nums2, nums1);
        if (n == 0) return ((double)nums1[(m - 1) / 2] + (double)nums1[m / 2]) / 2.0;
        int left = 0, right = n * 2;
        while (left <= right) {
            int mid2 = (left + right) / 2;
            int mid1 = m + n - mid2;
            double L1 = mid1 == 0 ? INT_MIN : nums1[(mid1 - 1) / 2];
            double L2 = mid2 == 0 ? INT_MIN : nums2[(mid2 - 1) / 2];
            double R1 = mid1 == m * 2 ? INT_MAX : nums1[mid1 / 2];
            double R2 = mid2 == n * 2 ? INT_MAX : nums2[mid2 / 2];
            if (L1 > R2) left = mid2 + 1;
            else if (L2 > R1) right = mid2 - 1;
            else return (max(L1, L2) + min(R1, R2)) / 2;
        }
        return -1;
    }
};

参考

http://www.cnblogs.com/grandyang/p/4465932.html
迭代解法