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 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106

解法：

自己写的代码：

　　首先想到的是类似于归并排序，从两个数组中依次选取较小的数据，然后index++，等到index到达中点附近时，如果是奇数则直接返回，如果是偶数则记录前后两个数字，然后返回平均值

　　代码如下：

//解法：依次从两个集合中选取较小的数据，每次选取计数，
//然后选到len/2附近，根据是否为偶数个获取对应元素，然后返回中位数
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2)
{
    int left = 0, right = 0;
    int len = nums1.size() + nums2.size();
    bool isEven = len % 2 == 0;

    int i = 0, j = 0;
    int idx = -1;
    //while ((i < nums1.size()) || (j < nums2.size()))
    while (idx < len)
    {
        if ((i < nums1.size()) && (j < nums2.size()))
        {
            if (nums1[i] < nums2[j])    //每次从两个集合中选取较小的数字;
            {
                left = nums1[i];
                i++;
            }
            else
            {
                left = nums2[j];
                j++;
            }
            idx++;
        }
        else if (i == nums1.size())
        {
            left = nums2[j];
            j++;
            idx++;
        }
        else if (j == nums2.size())
        {
            left = nums1[i];
            i++;
            idx++;
        }

        if (isEven)
        {
            if (idx == (len / 2 - 1))
            {
                if ((i < nums1.size()) && (j < nums2.size()))
                {
                    if (nums1[i] < nums2[j])    //每次从两个集合中选取较小的数字;
                    {
                        right = nums1[i];
                        i++;
                    }
                    else
                    {
                        right = nums2[j];
                        j++;
                    }
                    idx++;
                }
                else if (i == nums1.size())
                {
                    right = nums2[j];
                    j++;
                    idx++;
                }
                else if (j == nums2.size())
                {
                    right = nums1[i];
                    i++;
                    idx++;
                }

                return (left + right) / 2.0;
            }
        }
        else
        {
            //odd
            if (idx == (len - 1) / 2)
            {
                return left;
            }
        }
    };
    return 0;
}

然后提交结果：

 

 感觉好菜啊，不理解为什么占用那么多内存，因为最多访问一半的数据量。

• 空间复杂度：1
• 时间复杂度：O(m+n)
• 与题目要求不符

看解答：

 题解：

　　如何把时间复杂度降低到 O(\log(m+n))O(log(m+n)) 呢？如果对时间复杂度的要求有 \loglog，通常都需要用到二分查找，这道题也可以通过二分查找实现

　　题解讲解：https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/xun-zhao-liang-ge-you-xu-shu-zu-de-zhong-wei-s-114/

代码：

double getKthElement(vector<int>& nums1, vector<int>& nums2, int k)
{
    int m = nums1.size();
    int n = nums2.size();
    int idx1 = 0, idx2 = 0;

    while (true)
    {
        //特殊情况
        if (idx1 == m)    //如果一个vector已经移动超过范围，则直接去另一个vector中第k个元素
        {
            return nums2[idx2 + k - 1];
        }
        if (idx2 == n)
        {
            return nums1[idx1 + k - 1];
        }
        if (k == 1)    //如果k=1，则直接返回两个vector中第一个元素中较小的值
        {
            return min(nums1[idx1], nums2[idx2]);
        }

        //一般情况，首先获取各个vector中剩余元素的中间的idx
        int idx1New = min(idx1 + k / 2 - 1, m - 1);
        int idx2New = min(idx2 + k / 2 - 1, n - 1);

        if (nums1[idx1New] <= nums2[idx2New])//比较两个中间idx对应的值的大小
        {
            //k = k - (k / 2 - 1);            //???
            k = k - (idx1New - idx1 + 1);
            idx1 = idx1New + 1;
        }
        else
        {
            //k = k - (k / 2 - 1);//???
            k = k - (idx2New - idx2 + 1);

　　　　　　　　idx2 = idx2New + 1;

        }
    }
    return 0;
}
double findMedianSortedArrays2(vector<int>& nums1, vector<int>& nums2)
{
    //判断两个vector的总数量是奇数还是偶数，奇数直接取最中间数字，偶数则取中间两个然后平均值;
    int m = nums1.size();
    int n = nums2.size();

    if ((m + n) % 2 == 0)//偶数
    {
        int left = getKthElement(nums1, nums2, (m + n) / 2);
        int right = getKthElement(nums1, nums2, (m + n) / 2 + 1);
        return (left + right) / 2.0;    //注意要除以2.0，如果除以2则为int除法然后再转换为double
    }
    else//奇数
    {
        return getKthElement(nums1, nums2, (m + n) / 2 + 1);
    }
}

总结：

• 注意数据类型的隐式转换，如int/int再转换为double则会丢失小数部分，除法前先将其中一个转换为double
• 注意index的更新顺序，如此题中先更新k，然后再更新idx1 idx2
• TODO：代码运行太慢，需要对比答案