LeetCode第四题寻找两个有序数组的中位数（Python）

最新推荐文章于 2021-12-09 22:14:31 发布

SpongeB0bbb

最新推荐文章于 2021-12-09 22:14:31 发布

阅读量387

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/qq_21407487/article/details/102599301

版权

LeetCode 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

LeetCode第四题寻找两个有序数组的中位数（Python）

题目描述
解题方法和思路
- 方法1（自己想到的菜鸡实现,时间复杂度 $o (m + n)$ ）
- 方法2（LeetCode官方账号解答实现）

题目描述

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。
请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
你可以假设 nums1 和 nums2 不会同时为空。
示例 1:

nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0

示例 2:

nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题方法和思路

方法1（自己想到的菜鸡实现,时间复杂度 $o (m + n)$ ）

虽然看到时间复杂度有 $l o g$ ,就想到了二分法，但是实在想不出来。。。
因为题目指出两个原本的列表为有序的列表，因此，合并成一个有序的列表的做法可以从两个列表的一段开始逐个比较，将较小的那个列表的元素放入结果列表存储，并且相应的索引向后挪动，时间复杂度为 $o (m + n)$ ,合并以后找出中位数即可。
核心代码：

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:   
        length_nums1 = len(nums1)
        length_nums2 = len(nums2)
        middle_index = (length_nums1 + length_nums2) / 2
        i = 0
        j = 0
        k = 0
        result = []
        while i<length_nums1 and  j<length_nums2:
            if nums1[i]>=nums2[j]:
                result.append(nums2[j])
                j += 1
            else:
                result.append(nums1[i])
                i += 1
        while i<length_nums1:
            result.append(nums1[i])
            i += 1
        while j<length_nums2:
            result.append(nums2[j])
            j += 1
        if int(middle_index) == middle_index:
            return (result[int(middle_index)-1] + result[int(middle_index)])/2
        else:
            return result[int(middle_index)]

在这里插入图片描述

方法2（LeetCode官方账号解答实现）

在统计中，中位数被用来：

将一个集合划分为两个长度相等的子集，其中一个子集中的元素总是大于另一个子集中的元素。

如果理解了中位数的划分作用，我们就很接近答案了。
首先，让我们在任一位置 $i$ 将 $A$ 划分成两个部分：

          left_A             |        right_A
    A[0], A[1], ..., A[i-1]  |  A[i], A[i+1], ..., A[m-1]

由于 $A$ 中有 $m$ 个元素，所以我们有 $m + 1$ 种划分的方法 $\sim m)$ 。
我们知道：

len(left_A)= $i$ ,len(right_A)= $m - i$ .
注意：当 $i = 0$ 时，left_A 为空集，而当 $i = m$ 时, right_A 为空集。

采用同样的方式，我们在任一位置 $j$ 将 $B$ 划分成两个部分：

          left_B             |        right_B
    B[0], B[1], ..., B[j-1]  |  B[j], B[j+1], ..., B[n-1]

将 left_A 和 left_B 放入一个集合，并将 right_A 和 right_B 放入另一个集合。再把这两个新的集合分别命名为 left_part 和right_part：

          left_part          |        right_part
    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]

如果我们可以确认：

len(left_part)=len(right_part)
$m a x$ (left_part) $\leq$ $m i n$ (right_part)

那么，我们已经将 ${ A,B \}$ 中的所有元素划分为相同长度的两个部分，且其中一部分中的元素总是大于另一部分中的元素。那么：
$median=\frac{max(left\_part) + min(righr\_part)}{2}$
要确保这两个条件，我们只需要保证：

$i + j = m - i + n - j$ （或： $m - i + n - j + 1$ )
如果 $\geq m$ ，只需要使 $\sim m$ , $\frac {m + n + 1}{2} - i$
$\leq A[i]$ 以及 $\leq B[j]$

ps.1 为了简化分析，我假设 $A [i - 1]$ , $B [j - 1]$ , $A [i]$ , $B [j]$ 总是存在，哪怕出现 $i = 0$ ， $i = m$ ， $j = 0$ ，或是 $j = n$ 这样的临界条件。
我将在最后讨论如何处理这些临界值。

ps.2 为什么 $\geq m$ ？由于 $\leq i \leq m$ 且 $\frac{m + n + 1}{2} - i$ ，我必须确保 $j$ 不是负数。如果 $n < m$ ，那么 $j$ 将可能是负数，而这会造成错误的答案。

所以，我们需要做的是：

在 $[0 ， m]$ 中搜索并找到目标对象 $i$ ，以使：
$\leq A[i]$ 且 $\leq B[j]$ , 其中 $\frac{m + n + 1}{2} - i$

接着，我们可以按照以下步骤来进行二叉树搜索：

设 $i m i n = 0$ ， $i m a x = m$ , 然后开始在 $[i m i n, i m a x]$ 中进行搜索。
令 $\frac{imin+imax}{2}$ , $j=\frac{n+m+1}{2}-i$
现在我们有len(left_part)=len(right_part)。而且我们只会遇到三种情况：
- $\leq A[i]$ 且 $\leq B[j]$ :
这意味着我们找到了目标对象 $i$ ，所以可以停止搜索。
- $B [j - 1] > A [i]$ :
这意味着 $A [i]$ 太小，我们必须调整 ii 以使 $\leq A[i]$ 。
我们可以增大 $i$ 吗？
是的，因为当 $i$ 被增大的时候， $j$ 就会被减小。
因此 $B [j - 1]$ 会减小，而 $A [i]$ 会增大，那么 $\leq A[i]$ 就可能被满足。
我们可以减小 $i$ 吗？
不行，因为当 $i$ 被减小的时候， $j$ 就会被增大。
因此 $B [j - 1]$ 会增大，而 $A [i]$ 会减小，那么 $\leq A[i]$ 就可能不满足。
所以我们必须增大 $i$ 。也就是说，我们必须将搜索范围调整为 $[i + 1, i m a x]$ 。
因此，设 $i m i n = i + 1$ ，并转到步骤 2。
- $A [i - 1] > B [j]$ :
这意味着 $A [i - 1]$ 太大，我们必须减小 $i$ 以使 $A[i−1]\leq B[j]$ 。
也就是说，我们必须将搜索范围调整为 $[i m i n, i - 1]$ 。
因此，设 $i m a x = i - 1$ ，并转到步骤 2。

当找到目标对象 $i$ 时，中位数为：

$m a x (A [i - 1], B [j - 1])$ , 当 $m + n$ 为奇数时

$\frac{max(A[i-1],B[j-1])+min(A[i],B[j])}{2}$ , 当 $m + n$ 为偶数时

现在，让我们来考虑这些临界值 $i = 0, i = m, j = 0, j = n$ ,此时 $A [i - 1], B [j - 1], A [i], B [j]$ 可能不存在。
其实这种情况比你想象的要容易得多。

我们需要做的是确保 $max(left_part) \leq min(right_part)$ 。因此，如果 $i$ 和 $j$ 不是临界值（这意味着 $A [i - 1], B [j - 1], A [i], B [j]$ 全部存在）, 那么我们必须同时检查 $\leq A[i]$ 以及 $\leq B[j]$ 是否成立。
但是如果 $A [i - 1], B [j - 1], A [i], B [j]$ 中部分不存在，那么我们只需要检查这两个条件中的一个（或不需要检查）。
举个例子，如果 $i = 0$ ，那么 $A [i - 1]$ 不存在，我们就不需要检查 $\leq B[j]$ 是否成立。
所以，我们需要做的是：

在 $[0 ， m]$ 中搜索并找到目标对象 $i$ ，以使：
( $j = 0$ or $i = m$ or $\leq A[i]$ )
或是 ( $i = 0$ or $j = n$ or $\leq B[j]$ ), 其中 $\frac{m + n + 1}{2} - i$

在循环搜索中，我们只会遇到三种情况：

1.( $j = 0$ or $i = m$ or $\leq A[i]$ ) 或是 ( $i = 0$ or $j = n$ or $\leq B[j]$ )，这意味着 $i$ 是完美的，我们可以停止搜索。
2. $j > 0$ and $i < m$ and $B [j - 1] > A [i]$ 这意味着 $i$ 太小，我们必须增大它。
3. $i > 0$ and $j < n$ and $A [i - 1] > B [j]$ 这意味着 $i$ 太大，我们必须减小它。

感谢 @Quentin.chen 指出： $\implies j > 0$ 以及 $\implies j < n$ 始终成立，这是因为：

$\leq n, i<m \implies j=\frac{m+n+1}{2}-i>\frac{m+n+1}{2}-m\geq\frac{2m+1}{2}-m\geq0$
$\leq n, i>0 \implies j=\frac{m+n+1}{2}-i<\frac{m+n+1}{2}\leq\frac{2n+1}{2}\leq n$

所以，在情况 2 和 3中，我们不需要检查 $j > 0$ 或是 $j < n$ 是否成立。

def median(A, B):
    m, n = len(A), len(B)
    if m > n:
        A, B, m, n = B, A, n, m
    if n == 0:
        raise ValueError

    imin, imax, half_len = 0, m, (m + n + 1) / 2
    while imin <= imax:
        i = (imin + imax) / 2
        j = half_len - i
        if i < m and B[j-1] > A[i]:
            # i is too small, must increase it
            imin = i + 1
        elif i > 0 and A[i-1] > B[j]:
            # i is too big, must decrease it
            imax = i - 1
        else:
            # i is perfect

            if i == 0: max_of_left = B[j-1]
            elif j == 0: max_of_left = A[i-1]
            else: max_of_left = max(A[i-1], B[j-1])

            if (m + n) % 2 == 1:
                return max_of_left

            if i == m: min_of_right = B[j]
            elif j == n: min_of_right = A[i]
            else: min_of_right = min(A[i], B[j])

            return (max_of_left + min_of_right) / 2.0

作者：LeetCode
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/xun-zhao-liang-ge-you-xu-shu-zu-de-zhong-wei-shu-b/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

时间复杂度： $O (l o g (m i n (m, n)))$ ，
首先，查找的区间是 $[0, m]$ 。
而该区间的长度在每次循环之后都会减少为原来的一半。
所以，我们只需要执行 $l o g (m)$ 次循环。由于我们在每次循环中进行常量次数的操作，所以时间复杂度为 $O (l o g (m))$ 。
由于 $\leq n$ ，所以时间复杂度是 $O\big(\log\big(\text{min}(m,n)\big)\big)$ 。
空间复杂度： $O (1)$ ,
我们只需要恒定的内存来存储 $9$ 个局部变量，所以空间复杂度为 $O (1)$ 。

作者：LeetCode
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/xun-zhao-liang-ge-you-xu-shu-zu-de-zhong-wei-shu-b/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

SpongeB0bbb

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
LeetCode第四题寻找两个有序数组的中位数（Python）

LeetCode第四题寻找两个有序数组的中位数（Python）题目描述解题方法和思路方法1（自己想到的菜鸡实现,时间复杂度o(m+n)o(m+n)o(m+n)）方法2（LeetCode官方账号解答实现）题目描述给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。你可以假设 nums1 和...
复制链接

扫一扫