leetcode真是博大精深，难度为5的题真不是盖的，高人层出不穷, 下面直接学习一下网友[huoyao] 3的 [方法] 4
1. There are two sorted arrays A and B of size m and n respectively.
2. Find the median of the two sorted arrays.
3. The overall run time complexity should be O(log (m+n)).
leetcode给出的 tag 如下
Divide and Conquer
Array
Binary Search
简单翻译一下, 就是给出两个有序数组, 讲述组合并以后, 求出中位数。
中位数将一个数组分为数目相同的两半，数组长度为奇数， 那么中位数下标为 n/2+1, 长度为偶数的话, 中位数为 (n/2+1 + n/2-1)/2
要求算法的时间复杂度为O(log (m+n))
废话不多说，huoyao的算法如下
给定一个排好序的数组A, 长度为m, 可以划分为如下两个部分
{ A[0], A[1], ... , A[i - 1] } | { A[i], A[i + 1], ... , A[m - 1] }
左边的所有元素都小于右边的元素
左边有 i 个元素, 右边有 m-i 个元素
总共有 m+1 中划分方式(i = 0 ~ m)
当 i=0 , 左边有 0 个元素, 右边有 m 个元素
当 i=m , 左边有 m 个元素, 右边有 0 个元素
对于B数组, 也可以类似的划分
{ B[0], B[1], ... , B[j - 1] } | { B[j], B[j + 1], ... , B[n - 1] }
将A的左边与B的左边放到同一个集合中(取名 左部)
将A的右边与B的右边放到同一个集合中(取名 右部)
LeftPart | RightPart
{ 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. 左部的长度 = 右部的长度 (或者左部的长度 = 右部的长度+1)
2. 右部的所有元素都大于左部
那么我们已经将{A,B}中的元素划分为左右两个相同的部分, 中位数很容易就找到了
用算法的方式表示以上的条件, 如下
(1) i + j == m - i + n - j (or: m - i + n - j + 1)
if n >= m, we just need to set:
i = 0 ~ m, j = (m + n + 1) / 2 - i
(2) B[j - 1] <= A[i] and A[i - 1] <= B[j]
considering edge values, we need to ensure:
(j == 0 or i == m or B[j - 1] <= A[i]) and
(i == 0 or j == n or A[i - 1] <= B[j])
至此, 算法变为
Search i from 0 to m, to find an object "i" to meet condition (1) and (2) above.
现在开始引入 二分查找
循环遍历中, 当前的循环值为i0, j0, 若i0,j0是需要的解, 那么他们满足上述条件, 否则, 与条件相违背, 则有B[j0 - 1] > A[i0] 或者 A[i0 - 1] > B[j0],
如果B[j0 - 1] > A[i0], 那么 "ix" 不可能在 [0, i0]之中, why? :
因为如果 ix < i0, 那么jx = (m+n+1)/2-ix > j0,
那么 B[jx - 1] >= B[j0 - 1] > A[i0] >= A[ix]
而这个违反了 condition (2), ix 肯定不是解,
所以ix 不可能比i0小
同样的 ,如果 A[i0 - 1] > B[j0] , ix" 不可能在 [i0, m] 之中
所以算法进一步推算为:
1. set imin, imax = 0, m, then start searching in [imin, imax]
2. i = (imin + imax) / 2; j = (m + n + 1) / 2 - i
3. if B[j - 1] > A[i]: continue searching in [i + 1, imax]
elif A[i - 1] > B[j]: continue searching in [imin, i - 1]
else: bingo! this is our object "i"
以下是原作者的python代码
def Median2(A, B):
m, n = len(A), len(B)
if m > n:
return Median2(B, A)
imin, imax = 0, m
while imin <= imax:
i = (imin + imax) / 2
j = (m + n + 1) / 2 - i
if j > 0 and i < m and B[j - 1] > A[i]:
imin = i + 1
elif i > 0 and j < n and A[i - 1] > B[j]:
imax = i - 1
else:
if i == 0:
num1 = B[j - 1]
elif j == 0:
num1 = A[i - 1]
else:
num1 = max(A[i - 1], B[j - 1])
if (m + n) & 1:
return num1
if i == m:
num2 = B[j]
elif j == n:
num2 = A[i]
else:
num2 = min(A[i], B[j])
return (num1 + num2) / 2.0
以下是个人的一些难点解释
学习本就是一个痛苦的过程, 但是每有会意, 便欣然忘食, 也是一种快乐
-
中位数的概念
-
二分查找的引入, 原文说的不是十分好理解, 翻译的时候用红色的字体标示了
-
运算时必须保证A数组长度小于B：
i和j, 将AB两个数组划分为长度相同的两个集合, 如果A数组非常长, 那么i在划分中可能出现
len(A的右部加上B的全部) < len(A的左部)
的情况， 此时，j计算值为负。 -
边界值理解：
LeftPart | RightPart { 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] } 判断B[j-1] 是否小于 A[i]时候, 需要保证 j > 0 并且 i < m j > 0 理解: j如果等于0的话, 其实B组整个就划分为 RightPart了 i < m 理解: i如果等于m的话, 其实A组整个就划分为 LeftPart了 判断A[i - 1] 是否小于 B[j] 时候, 同样的, 需要保证 i > 0 并且 j < n -
java版本的实现, 有狗尾续貂之嫌
public double findMedianSortedArrays(int A[], int B[]) {
int m = A.length;
int n = B.length;
// 这里必须保证A长度小于B
// 理解: i和j, 将AB两个数组划分为长度相同的两个集合, 如果A数组非常长, 那么i在划分中可能出现
// len(A的右部加上B的全部) < len(A的左部)
// 的情况， 此时，j计算值为负。
if (m > n) {
return findMedianSortedArrays(B, A);
}
int imin = 0;
int imax = m;
int num1 = 0, i = 0, j = 0, num2 = 0;
while (imin <= imax) {
i = (imin + imax) / 2;
j = (m + n + 1) / 2 - i;
// 边界值需要保证
if (j > 0 && i < m && B[j - 1] > A[i]) {
imin = i + 1;
} else if (i > 0 && j < n && A[i - 1] > B[j]) {
imax = i - 1;
} else {
if (i == 0) {
num1 = B[j - 1];
} else if (j == 0) {
num1 = A[i - 1];
} else {
num1 = Math.max(A[i - 1], B[j - 1]);
}
break;
}
}
if ((m + n) % 2 == 1) {
return num1;
}
if (i == m) {
num2 = B[j];
} else if (j == n) {
num2 = A[i];
} else {
num2 = Math.min(A[i], B[j]);
}
return (num1 + num2) / 2.0;
}