题目
给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。
请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
你可以假设 nums1 和 nums2 不会同时为空。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
示例
示例 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(log(m + n))，然而暴力破解需要将两个数组进行排序，然后找到中位数，这样一来时间复杂度就成了O(m+n)，这与要求是不符的，接下来看一下官方是在限定的时间复杂度内怎么解决这道题的方法的思路：
方法：递归法 为了解决这个问题，我们需要理解 “中位数的作用是什么”。在统计中，中位数被用来：
将一个集合划分为两个长度相等的子集，其中一个子集中的元素总是大于另一个子集中的元素。
如果理解了中位数的划分作用，我们就很接近答案了。
首先，让我们在任一位置 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) max(left_part) ≤ min(right_part)
那么，我们已经将 {A,B} 中的所有元素划分为相同长度的两个部分，且其中一部分中的元素总是大于另一部分中的元素。那么：median= [max(left_part) + min(right_part)] / 2
要确保这两个条件，我们只需要保证：
- 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 为了简化分析，我假设 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，以使：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)。 而且我们只会遇到三种情况：
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。当找到目标对象 i 时，中位数为：
max(A[i−1],B[j−1]), 当 m + 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)。 因此，如果 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 = 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 太大，我们必须减小它。
其实，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 是否成立。作者：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） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
这个题题目乍一看，好好好好好简单，仔细一想感觉哪里不太对，看完答案觉得好好好好好难啊！
看一下官方给的代码，官方少有的给的python代码哦
代码1
def median(A, B):
m, n = len(A), len(B) #获取两个数组的长度
if m > n: #如果A数组的长度大于B数组的长度
A, B, m, n = B, A, n, m #就将他们的表示方法进行置换，以确保我们代码中A数组的长度是小于B数组的长度的
#还记得为什么要这么做吗？
#为什么 n ≥ m？由于0 ≤ i ≤ m 且 j = (m + n + 1) / 2 - i，必须确保 j 不是负数。如果
#n < m，那么 j 将可能是负数，而这会造成错误的答案。
if n == 0: #如果两个数组中长的那一个长度都为0，短的就更为0了，连个数组均为空，返回错误
raise ValueError
imin, imax, half_len = 0, m, (m + n + 1) / 2 #根据二叉树搜索法，定义imin，imax，以及两个数组的中值的坐标
while imin <= imax: #当imin <= imax
i = (imin + imax) / 2 #定义i的值
j = half_len - i #相应地求出j的值
if i < m and B[j-1] > A[i]: #如果i < m 并且 B[j-1] > A[i]，说明j大了，i小了
# i is too small, must increase it
imin = i + 1 #将imin置为i + 1
elif i > 0 and A[i-1] > B[j]: #如果i > 0 并且 A[i-1] > B[j]，说明i大了，j小了
# i is too big, must decrease it
imax = i - 1 #将imax置位i - 1
else: #如果i既没有过大也没有过小，此时是正好的，对应的j也是正好的
# i is perfect
if i == 0: max_of_left = B[j-1] #这时如果i为0，说明A数组中的数全都在合成数组的右半区，那么合成数组的左半区的数中最大的数就是B[j-1]
elif j == 0: max_of_left = A[i-1] #如果j为0，说明B数组中的数全都在合成数组的右半区，那么合成数组的左半区的数中最大的数就是A[i-1]
else: max_of_left = max(A[i-1], B[j-1]) #如果都不是上述两种极端情况，那么合成数组左半区中最大的数为A左半区中最大的数和B左半区中最大的数的最大值
if (m + n) % 2 == 1: #如果A和B一共有奇数个数
return max_of_left #那么中值直接就是合成数组左半区中的最大值
#如果A和B中一共有偶数个数，那么中值就要算出合成数组左半区的最大值和右半区的最小值
if i == m: min_of_right = B[j] #如果i = m，说明A全都在合成数组的左半区，那么右半区的最小值就是B[j]
elif j == n: min_of_right = A[i] #如果j = n，说明B全部都在合成数组左半区，那么右半区的最小值就是A[i]
else: min_of_right = min(A[i], B[j]) #如果都不是上述两种情况，那么右半区的最小值就是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）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
分析1
一道简单的求中值题竟然要考虑这么多问题，分别有：
- 中值的定义：在有序数组的最中间，中值左边的元素个数和右边的元素个数相等
- 中值的特点：中值左边的数中的最大值小于中值右边的数中的最小值
我们要求中值，就要最起码从中值的定义入手，固定住中值左边的个数和右边的个数相等，然后调整A和B的指针索引，来满足中值的特点 - 需要考虑各种极端情况，即两个数组中有一个数组全部在合成数组的同一个半区的情况，其实我看完代码之后，认为关键点是要知道什么时候去判断这种极端情况：
第一次判断是在求max_of_left的时候，为什么是在这个时候求呢，因为求这个值需要判断A[i-1]和B[j-1]的最大值，正常情况是max_of_left = max(A[i-1], B[j-1])，如果出现极端情况，那么索引可能会出错，例如如果B数组全部成员都在合成数组的右半区，那么i = (m + n + 1) / 2，j = 0，如果依然按照上面的算，那j - 1就小于零了，会出现错误。
第二次判断是在求min_of_right的时候，正常的求法是min_of_right = min(A[i], B[j])，如果出现极端情况呢，假设A数组的全部成员都在合成数组的左半区，那么此时i的值就应该为m - 1，但实际上A[i]还是在合成数组的左半区的，那么如果按照原求法就会出现错误，此时min_of_right = B[j]。
机智一点发现什么规律了没有？极端情况的出现都是在判断合成数组的左半区最大值和右半区最小值时才出现的。
接下来看一下耗时最短的python算法是如何进行一定程度的优化的：
代码2
class Solution:
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
m, n = len(nums1), len(nums2) #获取两个数组的长度
if m>n:
nums1, nums2, m, n = nums2, nums1, n, m #还是将长度短的数组作为第一个
imin = 0 #设置索引的下边界
imax = m #设置索引的上边界
halflen = (m+n+1)//2 #确定中值的索引
while imin<=imax: #如果二叉搜索没有结束
i = (imin + imax)//2 #定义数组1的索引
j = halflen - i #相应的求出数组2的索引
if i<m and nums1[i]<nums2[j-1]: #如果i小了，就将i的下界提高，来增大i
imin += 1
elif i>0 and nums1[i-1]>nums2[j]: #如果j小了，就将i的上界降低，来减小i
imax -= 1
else: #索引分配合适之后考虑极端情况
if i==0: #数组1全都在合成数组右半区
max_left = nums2[j-1]
elif j==0: #数组2全都在合成数组右半区
max_left = nums1[i-1]
else: #不是极端情况
max_left = max([nums1[i-1], nums2[j-1]])
if (m+n)%2==1: #如果合成数组一共有奇数个元素
return max_left #直接返回合成数组左半区的最小值
if i==m: #如果一共有偶数个元素，并且是极端情况中数组1全都在合成数组的左半区
min_right = nums2[j]
elif j==n:#极端情况中的数组2都在合成数组的左半区
min_right = nums1[i]
else: #一共有偶数个元素的时候的中指计算
min_right = min([nums1[i], nums2[j]])
return (max_left+min_right)/2.0
分析2
emmm感觉没啥有变化的地方啊，看来本题就这一种解法，代码也没有优化的地方了
总结
这道题题目看着简单，但实际分析起来是需要考虑好多问题的，这个在分析1里面也已经提到过了，总结一下就是如何利用中值的定义以及特点，什么时候去讨论极端情况，遇到的第一个难度为困难的题目，感觉真挺难的。
来源：https://blog.csdn.net/weixin_43269244/article/details/101062100