问题描述
- 给定两个大小为 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
我的答案
思考
输入两个有序数组,直接分别求出两个数组的中位数,然后将两个中位数相加除以二得出答案
代码
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int l1 = nums1.length;
int l2 = nums2.length;
float mid1 = 0;
float mid2 = 0;
float result = 0;
if(l1==0||l2==0){
return 0;
}
if(l1%2 != 0){
mid1 = nums1[(l1+1)/2-1];
}else{
float num1 = nums1[(l1/2)-1];
float num2 = nums1[(l1/2)];
mid1 = (num1+num2)/2;
}
if(l2%2 != 0){
mid2 = nums2[(l2+1)/2-1];
}else{
float num1 = nums2[(l1/2)-1];
float num2 = nums2[(l1/2)];
mid2 = (num1+num2)/2;
}
result = (mid1+mid2)/2;
return result;
}
}
问题
显然这个问题不会这么容易得出答案,而且时间复杂度几乎为1。在测试时输入的数是负数时不能得出正确答案,但是若我们将两个数组分别遍历然后合并再找中位数,就不能达到时间复杂度小于O(log(m+n))的要求,根据时间复杂度的要求,大概可以猜出需要使用二分查找法,但是如何将两个数组合并又是个问题,所以只能看看官方的算法。
最优解
算法思想
方法:递归法
为了解决这个问题,我们需要理解“中位数的作用是什么”。在统计中,中位数被用来:
将一个集合划分为两个长度相等的子集,其中一个子集中的元素总是大于另一个子集中的元素。
如果理解了中位数的划分作用,我们就很接近答案了。
首先,让我们在任一位置 i 将A 划分成两个部分:
left_A| right_A
A[0], A[1], …, A[i-1] | A[i], A[i+1], …, A[m-1]
由于 \text{A}A 中有 mm 个元素, 所以我们有 m+1m+1 种划分的方法(i = 0 \sim mi=0∼m)。
我们知道:
len(left_A)=i,len(right_A)=m−i.
注意:当 i = 0i=0 时,left_A 为空集, 而当 i = mi=m 时,right_A 为空集。
采用同样的方式,我们在任一位置 jj 将 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 + 1m−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}
m+n+1
−i,我必须确保 j 不是负数。如果n<m,那么 j 将可能是负数,而这会造成错误的答案。
所以,我们需要做的是:
< 在 [0,m][0,m] 中搜索并找到目标对象 ii,以使:
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 - 现在我们有 len(left_part)=len(right_part)。 而且我们只会遇到三种情况:
-
A[i]B[j−1]≤A[i] 且 B[j]A[i−1]≤B[j]:
这意味着我们找到了目标对象 i,所以可以停止搜索。 -
A[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。
也就是说,我们必须将搜索范围调整为 max[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,
max(A[i−1],B[j−1]) + min(A[i],B[j]),当 m + nm+n 为偶数时
代码
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;
}
}
复杂度分析
-
时间复杂度:O(log(min(m,n))),
首先,查找的区间是 [0,m]。 而该区间的长度在每次循环之后都会减少为原来的一半。 所以,我们只需要执行 log(m) 次循环。由于我们在每次循环中进行常量次数的操作,所以时间复杂度为O(log(m))。由于m≤n,所以时间复杂度是 O(log(min(m,n)))。 -
空间复杂度:O(1), 我们只需要恒定的内存来存储 9 个局部变量, 所以空间复杂度为 O(1)。