面试中遇到的两个有序数组的中位数问题

1.面试中遇到 两个有序数组的中位数 的问题

今年上半年年初，3,4月份找工作的时候，面有一家公司时（上海，当时在上海找工作），有一道手撕代码题：有两个有序的数组，求这两个有序数组合成一个有序数组时的中位数。
当时面试也没有经常手撕代码，而且遇见手撕的情况也基本是一些简单的快排，二分等。当时的想法很简单：第一步,把两个数组合并成一个一个数组。第二部，找出合并出数组的中位数。
写完之后交给面试官，面试官看过之后，问我你写的这种方法的时间复杂度和空间复杂度，然后又问我有没有更简便的方法，当时我就陷入了沉思。因为我当时帮两个有序数组和成一个有序的数组这个过程比较复杂，记得当时用了两个for循环，想了半天最后也没有想出来

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

原来当时自己的思路太僵硬了，没有考虑到中位数的性质，具体的解题思路如下：
方法：递归法
为了解决这个问题，我们需要理解 “中位数的作用是什么”。在统计中，中位数被用来：
将一个集合划分为两个长度相等的子集，其中一个子集中的元素总是大于另一个子集中的元素。

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

首先，让我们在任一位置 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(left_A) = i, len(right_A) = m - i

注意：

当 i = 0i=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)
max(left_part)≤min(right_part)

那么，我们已经将{A,B} 中的所有元素划分为相同长度的两个部分，且其中一部分中的元素总是大于另一部分中的元素。那么：
$$\boxed{median=\frac{max(leftPart)+min(rightPart)}{2}}$$

要确保这两个条件，我们只需要保证：

i + j = m - i + n - j（或：m - i + n - j + 1） 如果 n≥m，只需要使 i = 0 ∼ m ,
$$\boxed{j=\frac{m+n+1}{2}-i}$$

B[j−1] ≤ A[i] 以及 A[i−1] ≤ B[j]

ps.1 为了简化分析，我假设 A[i−1],B[j−1],A[i],B[j] 总是存在，哪怕出现i=0，i=m , j=0，或是 j=n 这样的临界条件。
我将在最后讨论如何处理这些临界值。
ps.2 为什么n≥m？由于 0 ≤ i ≤ m 且 $$\boxed{j=\frac{m+n+1}{2}-i}$$我必须确保 j 不是负数。如果 n<m，那么 j 将可能是负数，而这会造成错误的答案。

所以，我们需要做的是：
在[0，m] 中搜索并找到目标对象 i，以使：
B[j−1]≤A[i] 且A[i−1]≤B[j], 其中$$j=\frac{m+n+1}{2}-i$$
接着，我们可以按照以下步骤来进行二叉树搜索：
设 imin=0，imax=m, 然后开始在 [imin,imax] 中进行搜索。

令 $$i=\frac{\text{imin}+\text{imax}}{2}，j=\frac{m+n+1}{2}-i$$
现在我们有 len(left_part)=len(right_part)。 而且我们只会遇到三种情况：

B[j−1]≤A[i] 且 A[i−1]≤B[j]： 这意味着我们找到了目标对象 i，所以可以停止搜索。

B[j−1]>A[i]： 这意味着 A[i] 太小，我们必须调整 i 以使 B[j−1]≤A[i]。 我们可以增大 i 吗？
是的，因为当 i 被增大的时候，j 就会被减小。
因此 B[j−1] 会减小，而 A[i] 会增大，那么 B[j−1]≤A[i] 就可能被满足。 我们可以减小 i 吗？
不行，因为当 i 被减小的时候，j 就会被增大。
因此 B[j−1] 会增大，而A[i] 会减小，那么B[j−1]≤A[i] 就可能不满足。 所以我们必须增大 ii。也就是说，我们必须将搜索范围调整为 [i+1,imax]。 因此，设 imin=i+1，并转到步骤 2。

A[i−1]>B[j]： 这意味着A[i−1] 太大，我们必须减小 i 以使 A[i−1]≤B[j]。
也就是说，我们必须将搜索范围调整为[imin,i−1]。 因此，设 imax=i−1，并转到步骤 2。

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

max(A[i−1],B[j−1]), 当 m+n 为奇数时

$$\frac{\max (\text{A}[i-1],\text{B}[j-1])+\min (\text{A}[i],\text{B}[j])}{2}$$

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

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

所以，我们需要做的是：
在 [0，m] 中搜索并找到目标对象 i，以使：
(j = 0 or i=m or B[j−1]≤A[i]) 或是(i = 0 or j=n or A[i−1]≤B[j]), 其中$$j=\frac{m+n+1}{2}-i$$
在循环搜索中，我们只会遇到三种情况：

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

3.代码实现

3.1java版

class Solution {
    public double findMedianSortedArrays(int[] A, int[] B) {
        int m = A.length;
        int n = B.length;
        if (m > n) { // to ensure m<=n
            int[] temp = A; A = B; B = temp;
            int tmp = m; m = n; n = tmp;
        }
        int iMin = 0, iMax = m, halfLen = (m + n + 1) / 2;
        while (iMin <= iMax) {
            int i = (iMin + iMax) / 2;
            int j = halfLen - i;
            if (i < iMax && B[j-1] > A[i]){
                iMin = i + 1; // i is too small
            }
            else if (i > iMin && A[i-1] > B[j]) {
                iMax = i - 1; // i is too big
            }
            else { // i is perfect
                int maxLeft = 0;
                if (i == 0) { maxLeft = B[j-1]; }
                else if (j == 0) { maxLeft = A[i-1]; }
                else { maxLeft = Math.max(A[i-1], B[j-1]); }
                if ( (m + n) % 2 == 1 ) { return maxLeft; }

                int minRight = 0;
                if (i == m) { minRight = B[j]; }
                else if (j == n) { minRight = A[i]; }
                else { minRight = Math.min(B[j], A[i]); }

                return (maxLeft + minRight) / 2.0;
            }
        }
        return 0.0;
    }
}

3.2python版

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） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。