4. 寻找两个有序数组的中位数

4. 寻找两个有序数组的中位数

题目描述

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。

进阶：你能设计一个时间复杂度为 $O(log(m+n))$ 的算法解决此问题吗？

示例1

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例2

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

示例3

输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000

示例4

输入：nums1 = [], nums2 = [1]
输出：1.00000

示例5

输入：nums1 = [2], nums2 = []
输出：2.00000

提示：

• $nums1.length==m$
• $nums2.length==n$
• $0\le m\le 1000$
• $0\le n\le 1000$
• $1\le m+n\le 2000$
• $-10^6\le nums1[i],nums2[i]\le 10^6$

---

题解：

这题本质就是求两个有序数组整体第 k 小元素：

1. 元素个数为奇数：只需要求第 $(n+m)/2$ 小元素
2. 元素个数为偶数：需要求第 $(n+m)/2$ 小和 $(n+m)/2+1$ 小元素的平均值

而找第 k 小可参考我的两篇博客：

1. 在两个长度相等的排序数组中找到上中位数
2. 在两个排序数组中找到第k小的数

getUpMedian 是求两个长度相等的有序数组的上中位数，时间复杂度为：$O(logn)$
findKthNum 是求两个有序数组的整体第 k 小，其时间复杂度为：$O(log(min(m,n)))$

但从提交的结果来看，速度并不快。。。搞半天搞了个寂寞。

代码：

class Solution {
public:
    int getUpMedian( vector<int>& nums1, int l1, int r1, vector<int>& nums2, int l2, int r2 ) {
        if ( nums1[r1] <= nums2[l2] || nums2[r2] <= nums1[l1] )
            return min( nums1[r1], nums2[r2] );
        int m1, m2, offset;
        while ( l1 < r1 ) {
            m1 = (l1 + r1) >> 1;
            m2 = (l2 + r2) >> 1;
            offset = ((r1 - l1 + 1) & 1) ^ 1;
            if ( nums1[m1] > nums2[m2] ) {
                r1 = m1;
                l2 = m2 + offset;
            } else if ( nums1[m1] < nums2[m2] ) {
                l1 = m1 + offset;
                r2 = m2;
            } else return nums1[m1];
        }
        return min( nums1[l1], nums2[l2] );
    }
    int findKthNum( vector<int>& nums1, vector<int>& nums2, int k ) {
        int n1 = nums1.size(), n2 = nums2.size();
        if ( k < 1 || k > n1 + n2 ) return 0;
        if ( k <= n1 ) return getUpMedian( nums1, 0, k - 1, nums2, 0, k - 1 );
        if ( k > n2 ) {
            if ( nums1[k - n2 - 1] >= nums2[n2 - 1] )
                return nums1[k - n2 - 1];
            if ( nums2[k - n1 - 1] >= nums1[n1 - 1] )
                return nums2[k - n1 - 1];
            return getUpMedian( nums1, k - n2, n1 - 1, nums2, k - n1, n2 - 1 );
        }
        if ( nums2[k - n1 - 1] >= nums1[n1 - 1] ) return nums2[k - n1 - 1];
        return getUpMedian( nums1, 0, n1 - 1, nums2, k - n1, k - 1 );
    }
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int n1 = nums1.size();
        int n2 = nums2.size();
        int n = n1 + n2;
        int t;
        if ( !n1 || !n2 ) {
            if ( !n1 ) {
                if ( !n2 ) return 0;
                else {
                    t = n2 >> 1;
                    if ( n2 & 1 ) return nums2[t];
                    else return ( nums2[t - 1] + nums2[t] ) / 2.0;
                }
            } else {
                t = n1 >> 1;
                if ( n1 & 1 ) return nums1[t];
                else return ( nums1[t - 1] + nums1[t] ) / 2.0;
            }
        }
        if ( n1 > n2 ) swap( nums1, nums2 );
        t = n >> 1;
        if ( n & 1 ) {
            return findKthNum( nums1, nums2, t + 1 );
        } else {
            int a = findKthNum( nums1, nums2, t );
            int b = findKthNum( nums1, nums2, t + 1 );
            return ( a + b ) / 2.0;
        }
    }
};
/*
时间：44ms，击败：95.13%
内存：87.2MB，击败：91.36%
*/