题目

There are two sorted arrays nums1 and nums2 of size m and n respectively.
Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).
You may assume nums1 and nums2 cannot be both empty.
Example 1:

1
2
nums1 = [1, 3]
nums2 = [2]

The median is 2.0
Example 2:

1
2
nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

分析

要求很简单，给定两个不全为空的数组，求他们两个数组合在一起后的中位数，首先，我们要直到

  1. 中位数是什么？ 回顾一下中位数的定义，如果某个有序数组长度是奇数，那么其中位数就是最中间那个，如果是偶数，那么就是最中间两个数字的平均值。
  2. 我们要明确，这道题是给定了时间复杂度了的，即O(log (m+n))，是一个log复杂度，所以肯定不是遍历。
    其实看到log很容易想到二分法，但是如何在两个数组中利用二分法求中位数呢？
    假设两个有序数组的长度分别为m和n，由于两个数组长度之和 m+n 的奇偶不确定，因此需要分情况来讨论，对于奇数的情况，直接找到最中间的数即可，偶数的话需要求最中间两个数的平均值。为了简化代码，不分情况讨论，我们使用一个小trick，我们分别找第 (m+n+1) / 2 个，和 (m+n+2) / 2 个，然后求其平均值即可，这对奇偶数均适用。加入 m+n 为奇数的话，那么其实 (m+n+1) / 2 和 (m+n+2) / 2 的值相等，相当于两个相同的数字相加再除以2，还是其本身。

详细讲解可以仔细研读官方给出的解决方案，这里只说几个重点
好，这里我们需要定义一个函数来在两个有序数组中找到第K个元素，下面重点来看如何实现找到第K个元素。

  1. 降低复杂度的特殊情况
    首先，为了避免产生新的数组从而增加时间复杂度，我们使用两个变量i和j分别来标记数组nums1和nums2的起始位置。然后来处理一些corner cases（边缘情况），比如当某一个数组的起始位置大于等于其数组长度时，说明其所有数字均已经被淘汰了，相当于一个空数组了，那么实际上就变成了在另一个数组中找数字，直接就可以找出来了。还有就是如果K=1的话，那么我们只要比较nums1和nums2的起始位置i和j上的数字就可以了。
  2. 对谁进行二分？
    难点就在于一般的情况怎么处理？因为我们需要在两个有序数组中找到第K个元素，为了加快搜索的速度，我们要使用二分法，那么对谁二分呢，数组么？其实要对K二分，意思是我们需要分别在nums1和nums2中查找第K/2个元素，注意这里由于两个数组的长度不定，所以有可能某个数组没有第K/2个数字，所以我们需要先check一下，数组中到底存不存在第K/2个数字，如果存在就取出来，否则就赋值上一个整型最大值。如果某个数组没有第K/2个数字，那么我们就淘汰另一个数字的前K/2个数字即可。有没有可能两个数组都不存在第K/2个数字呢，这道题里是不可能的，因为我们的K不是任意给的，而是给的m+n的中间值，所以必定至少会有一个数组是存在第K/2个数字的。
  3. 二分法
    最后就是二分法的核心啦，比较这两个数组的第K/2小的数字midVal1和midVal2的大小，如果第一个数组的第K/2个数字小的话，那么说明我们要找的数字肯定不在nums1中的前K/2个数字，所以我们可以将其淘汰，将nums1的起始位置向后移动K/2个，并且此时的K也自减去K/2，调用递归。反之，我们淘汰nums2中的前K/2个数字，并将nums2的起始位置向后移动K/2个，并且此时的K也自减去K/2，调用递归即可，参见代码如下：

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size(), left = (m + n + 1) / 2, right = (m + n + 2) / 2;
        return (findKth(nums1, 0, nums2, 0, left) + findKth(nums1, 0, nums2, 0, right)) / 2.0;
    }
    int findKth(vector<int>& nums1, int i, vector<int>& nums2, int j, int k) {
        if (i >= nums1.size()) return nums2[j + k - 1];
        if (j >= nums2.size()) return nums1[i + k - 1];
        if (k == 1) return min(nums1[i], nums2[j]);
        int midVal1 = (i + k / 2 - 1 < nums1.size()) ? nums1[i + k / 2 - 1] : INT_MAX;
        int midVal2 = (j + k / 2 - 1 < nums2.size()) ? nums2[j + k / 2 - 1] : INT_MAX;
        if (midVal1 < midVal2) {
            return findKth(nums1, i + k / 2, nums2, j, k - k / 2);
        } else {
            return findKth(nums1, i, nums2, j + k / 2, k - k / 2);
        }
    }
};

代码运行过程

我们假设两个有序数组分别是
num1：[1，5，6，9]
num2：[3，7，8]
那么我们带入到上述代码中运行，观察运行情况

  1. 首先，我们根据两个数组总长度确定left=4和right=4。
  2. 计算(num1，i=0，num2，j=0，k=4)
    我们先不管前三个特殊判断，直接看接下来的赋值，
  3. 第一次迭代
    midVal1=5，midVal2=7（位置i+k/2-1）
    然后比较大小midVal1与midVal2的大小，小的元素所在的数组(i=i+k/2)继续带入（num1，i=2，num2，j=0，k=k-k/2=2）
  4. 第二次迭代
    midVal1=6，midVal2=3（大的元素随着k的减小而往前收缩），（num1，i=2，num2，j=1，k=k-k/2=1）
  5. 第三次迭代，此时k等于1，执行特殊判断(3)，num1[i=2]=6，num2[j=1]=7，取最小值6，找到。

我们再来看一个例子：
num1：[6]
num2：[1，5，7，8，10]

  1. 初始化：left=3，right=4

首先计算left分支（k=3）：

  1. i=0，j=0，k=3；均取头元素，num1[0]>num2[0]，j=k/2，k=k-k/2
  2. i=0，j=1，k=2，num1[0]>num2[1]，j=k/2，k=k-k/2
  3. k=1，return min(6,7)=6；

下面计算right分支（k=4）:

  1. i=0，j=0，k=4；此时并无i+k/2-1，所以设置midVal1=无穷，这样midVal2一定是比较小的，j=k/2，k=k-k/2
  2. i=0，j=2，k=2；此时midVal1收缩到num1[0]，与num2[2]比较
  3. i=1，j=2，k=1，此时i=num1.size()，执行第一判断，return num2[2]=7

所以最后结果是（6+7）/2

总结

可以看出，有些限制复杂度的题，更是给了我们足够的提示，log（m+n）代表不能遍历数组，而且需要二分，如何将二分和中位数的判断紧密的结合起来，是个难题。也是这道题在Leetcode处于Hard的原因，

  1. 首先，我们要掌握二分法在两个数组中的处理方式
  2. 判断好边界情况

参考内容

  1. [LeetCode] Median of Two Sorted Arrays 两个有序数组的中位数
  2. Leetcode官方解法