其他平台文章地址
github: https://github.com/yaodebian/algorithm-blogs/issues/3
知乎：https://zhuanlan.zhihu.com/p/83552320
问题描述
给定两个大小为 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
接着给出我自己的解决方法：（以下代码的时间复杂度为O(m + n)，但是仍然通过LeetCode编译器编译是通过的，显然不符合题目要求，但也不失为一种比较好的方法）
/**
* @param {number[]} nums1
* @param {number[]} nums2
* @return {number}
*/
var findMedianSortedArrays = function(nums1, nums2) {
// 声明一个临时的数组用于存储两数组合并之后的有序数列
var temp = []
// 声明两个数列的下标
var i, j
// 循环遍历，先将较小的数存入数组当中（当然也可以将较大的数先存入）
for (i = 0, j = 0; i < nums1.length && j < nums2.length;) {
if (nums1[i] <= nums2[j]) {
temp.push(nums1[i])
i++
} else {
temp.push(nums2[j])
j++
}
}
// 将两个数列当中剩余的元素存入临时数列当中
if (i < nums1.length) {
for (; i < nums1.length; i++) {
temp.push(nums1[i])
}
} else {
for (; j < nums2.length; j++) {
temp.push(nums2[j])
}
}
// 计算中位数需要的元素在临时数列当中的下标，并通过下标计算中位数
if ((temp.length - 1) % 2 === 0) {
return temp[(temp.length - 1) / 2]
} else {
var l = Math.floor((temp.length - 1) / 2)
var r = Math.ceil((temp.length - 1) / 2)
return (temp[l] + temp[r]) / 2
}
}
上面自己设计的算法其时间复杂度由临时数组的构建决定，故而也就是(m + n)次push操作，所以其时间复杂度为O(m + n)，下面是通过LeetCode编译后的成功结果页。。。
接下来，我们看下官方的题解是怎样的：（实际上这道题的标签是二分查找，自己设计的算法并没有用到二分查找）
先看代码（以下以javascript的形式展现）
// 找出两个有序数组并集的中位数
function findMedianSortedArrays (arr1, arr2) {
let m = arr1.length
let n = arr2.length
if (m > n) {
let tempArr = arr1
arr1 = arr2
arr2 = tempArr
let tempNum = m
m = n
n = tempNum
}
let iMin = 0, iMax = m, halfLen = Math.floor((m + n + 1) / 2)
while (iMin <= iMax) {
let i = Math.ceil((iMin + iMax) / 2)
let j = halfLen - i
if (i < iMax && arr2[j - 1] > arr1[i]) {
iMin = i + 1
} else if (i > iMin && arr1[i - 1] > arr2[j]) {
iMax = i - 1
} else {
let maxLeft = 0
if (i === 0) {
maxLeft = arr2[j - 1]
} else if (j === 0) {
maxLeft = arr1[i - 1]
} else {
maxLeft = Math.max(arr1[i - 1], arr2[j - 1])
}
if ((m + n) % 2 === 1) {
return maxLeft
}
let minRight = 0
if (i === m) {
minRight = arr2[j]
} else if (j === n) {
minRight = arr1[i]
} else {
minRight = Math.min(arr1[i], arr2[j])
}
return (maxLeft + minRight) / 2
}
}
}
方法：递归法（注意：以下涉及到除2的公式都是基于java等编程语言，故而获得的值均会向上取整）
为了解决这个问题，我们需要理解 “中位数的作用是什么”。在统计中，中位数被用来：
将一个集合划分为两个长度相等的子集，其中一个子集中的元素总是大于另一个子集中的元素。
如果理解了中位数的划分作用，我们就很接近答案了。
首先，让我们在任一位置 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 = 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) 或 len(left_part)=len(right_part) + 1
max(left_part)≤min(right_part)
那么，我们已经将 {A,B} 中的所有元素划分为大致长度相等的两个部分，且其中一部分中的元素总是大于另一部分中的元素。那么：
median = max(left_part)+min(right_part) / 2 或 median = max(left_part)
要确保这两个条件，我们只需要保证：
- i+j=m−i+n−j（或：m - i + n - j + 1）
如果 n≥m，只需要使 i=0∼m, j= (m+n+1) / 2 - i- B[j−1]≤A[i] 以及 A[i−1]≤B[j]
ps.1 为了简化分析，我假设 [j]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 且 j= (m+n+1) / 2 - i
我必须确保 j 不是负数。如果 n < m，那么 j 将可能是负数，而这会造成错误的答案。
所以，我们需要做的是：
在 [0，m] 中搜索并找到目标对象 i，以使：
B[j−1]≤A[i] 且 A[i−1]≤B[j], 其中 j= (m+n+1) / 2 - i
接着，我们可以按照以下步骤来进行二叉树搜索：
- 设 imin=0，imax=m, 然后开始在 [imin,imax] 中进行搜索。
- i= (imin + imax) / 2，j= (m+n+1) / 2 - i
- 现在我们有 len(left_part) = len(right_part) 或 len(left_part) = len(right_part) + 1。 而且我们只会遇到三种情况：
- 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] 就可能不满足。
所以我们必须增大 i。也就是说，我们必须将搜索范围调整为 [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 + nm+n 为奇数时
(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)≤min(right_part)。 因此，如果 ii 和 jj 不是临界值（这意味着 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=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 = (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 太大，我们必须减小它。
感谢 @Quentin.chen 指出：i<m⟹j>0 以及 i>0⟹j<n 始终成立，这是因为：
m≤n, i<m⟹j= ((m + n + 1) / 2 - i) > ((m + n + 1) / 2 - m) > ((2m + 1) / 2 - m) ≥ 0
m≤n, i>0⟹j= ((m + n + 1) / 2 - i) < ((m + n + 1) / 2) <= ((2n + 1) / 2) <= n
所以，在情况 2 和 3中，我们不需要检查 j > 0 或是 j < n 是否成立。
