算法｜LeetCode（力扣）经典题：二分查找/分治算法

二分查找/分治算法

更多请查看我的专栏：LeetCode（力扣）刷题指南

可直接在LeetCode中搜索题目名称

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

给定两个大小为 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

---

1.1 解决方案

​ 为了解决这个问题，我们需要理解 “中位数的作用是什么”。在统计中，中位数被用来：

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

如果理解了中位数的划分作用，我们就很接近答案了。

​ 首先，让我们在任一位置 $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$ 种划分的方法（$i=0$~$m$）。

​ 我们知道：

$len(lef{t}_A)=i,len(righ{t}_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]

如果我们可以确认：

1. $len(lef{t}_{part})=len(righ{t}_{part})$
2. $\max (lef{t}_{part})\le \min (righ{t}_{part})$

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

1. $i+j=m-i+n-j$（或：$m-i+n-j+1$）；如果 $n\ge m$，只需要使 $i=0$~$m$，$j=\frac{m+n+1}{2}-i$

2. $B[j-1]\le A[i]$以及 $A[i-1]\le B[j]$

1. 为了简化分析，假设 $A[j-1],B[j-1],A[j],B[j]$总是存在，哪怕出现 $i=0,i=m,j=0,j=n$ 这样的临界条件。
2. 为什么 $n\ge m$ ？由于 $0\le i\le m$ 且 $j=\frac{m+n+1}{2}-i$，必须确保 $j$ 不是负数。如果 $n<m$ ，那么 $j$ 可能是负数，而这会导致错误的答案。

所以，我们需要做的是：

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

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

1. 设imin=0,imax=m,然后开始在[imin,imax]中进行搜索；

2. 令 $i=\frac{imin+imax}{2},j=\frac{m+n+1}{2}-i$

3. 现在 $len(lef{t}_{part})=len(righ{t}_{part})$，我们会遇见以下三种情况：

   • $B[j-1]\le A[i]$且 $A[i-1]\le B[j]$，则查找结束；
   • $B[j-1]>A[i]$：i太小，我们必须调整 $i$ 以使 $B[j-1]\le A[i]$ ：将搜索范围调整为 [i+1,imax]，因此设imin=i+1，并转到步骤2；
   • $A[i-1]>B[j]$：i太大：将搜索范围调整为 [imin,i-1]，因此设imax=i-1，并转到步骤2；

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

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

我们还需要考虑临界值 $i=0,i=m,j=0,j=n$，此时 $A[i-1],B[j-1],A[i],B[j]$ 可能不存在。

1.2 思考与总结

class Solution:
    def findMedianSortedArrays(self, A: List[int], B: List[int]) -> float:
        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  #m=2,n=3,m+n+1=6,half_len=3
        while imin <= imax:
            i = (imin + imax) // 2  #i=1
            j = half_len - i   #j=3-1=2
            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