题目
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:
nums1 = [1, 3]
nums2 = [2]
The median is 2.0
Example 2:
nums1 = [1, 2]
nums2 = [3, 4]
The median is (2 + 3)/2 = 2.5
题意
给定两个有序数组,且并不都为空,找出两个有序数组的中位数,要求时间复杂度是O(log(m+n))。
分析
【方法1】最暴力的解法是将两个数组合并为一个,然后找中位数,该方法的时间复杂度是O(m+n),不符合题意,遂弃之。
【方法2】看到时间复杂度要求,可以想到使用二分查找法。于是就有了如下的解决思路:
假设两个数组分别为A和B,A数组的元素个数为m,B数组的元素个数为n。
在A数组的随机位置将数组A分成两部分,即left_A | right_A,A数组即: A[0], A[1], ...,A[i-1], A[i], A[i+1],..., A[m-1]。因为A有m个元素,所以共有m+1种切割方法(i = 0 ~ m),其中:left_A.size() = i,right_A.size() = m-i。i = 0 时,left_A.size() = 0; i = m时,right_A.size() = m。
在B数组也做类似的操作:left_B | right_B,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]
如果可以保证:
(1) left_part.size() == right_part.size()
(2) max(left_part) <= min(right_part)
那么将{A,B}中的所有元素划分为两个长度相等的部分,一个部分总是大于另一个部分。然后中值 = (max(left_part) + min(right_part))/2。
为了确保这个条件,只需要确保两个条件:
(1)i + j = m-i + n - j(或:m-i + n- j + 1)
如果n>=m,则i = 0 ~m,j = (m+n+1)/2 - i
[tips]为什么要确保n>=m,因为必须确保 j 是合法索引,因为 0<=i<=m 和 j = (m+n+1)/2 - i,如果n<m,则 j 可以是负数,这将导致错误的结果。
(2) B[j-1] <= A[i] 并且A[i-1] <= B[j]
在[0,m]中搜索i,找到一个切分点i (j = (m + n + 1)/2 - i):使得B[j-1] <= A[i]和A[i-1] <= B[j]。可以按照以下步骤进行搜索:
① 设置imin = 0,imax = m,然后开始搜索[imin, imax];
②设置i = (imin + imax)/2, j = (m+n+1)/2- i;
③现在left_part.size() = right_part.size(),而且只有三种情况:
(1) B[j-1] <= A[i] 和 A[i-1] <= B[j],意味着找到了切分点i,停止搜索。
(2) B[j-1] > A[i],意味着A[i]太小,必须调整i 得到B[j-1] <= A[i]。只能增加i,因为当i减小时j将增加,因此B[j-1]增加并且A[i]减小,永远不会满足。所以调整搜索范围为[i+1,imax],即imin = i+1,然后回到第②步。
(3)A[i-1] > B[j],意味着A[i-1]太大,必须减小 i 得到A[i-1] <= B[j]。因此设置imax = i -1,然后回到第②步。
当找到切分点i时,中值为:
- 当m+n为奇数时,中值为max(A[i-1], B[j-1])
- 当m+n为偶数时,中值为((max(A[i-1], B[j-1]) + min(A[i], B[i]))/2
C++代码实现:
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int len1 = nums1.size();
int len2 = nums2.size();
//printf("len1 = %d, len2 = %d\n", len1, len2);
if(len1 == 0 && len2 > 0) {
if(len2 % 2 == 0)
return (nums2[len2/2] + nums2[len2/2 - 1])/2.0;
else
return nums2[len2/2];
} else if (len2 == 0 && len1 > 0) {
if(len1 % 2 == 0)
return (nums1[len1/2] + nums1[len1/2 - 1])/2.0;
else
return nums1[len1/2];
}
if(len1 > len2) {
return findMedianSortedArrays(nums2, nums1);
}
int imin = 0, imax = len1;
int i,j;
// printf("imax = %d\n", imax);
int left_part_max;
int right_part_min;
while(imin <= imax) {
i = imin + (imax - imin)/2;
j = (len1 + len2 + 1)/2 - i;
// printf("i = %d, j = %d\n", i, j);
// printf("nums1[i-1]=%d,nums2[j]=%d,nums2[j-1]=%d,nums1[i]=%d\n");
if (i < len1 && j > 0 && nums2[j-1] > nums1[i]) {
// printf("Adjust imin!\n");
imin = i + 1;
} else if (i > 0 && j < len2 && nums1[i-1] > nums2[j]) {
// printf("Adjust imax!\n");
imax = i - 1;
} else {
if(i == 0)
left_part_max = nums2[j-1];
else if(j == 0)
left_part_max = nums1[i-1];
else
left_part_max = nums1[i-1] > nums2[j-1]? nums1[i-1]:nums2[j-1];
break;
}
}
if((len1 + len2) % 2 != 0) {
return left_part_max;
}
if(i == len1) {
right_part_min = nums2[j];
} else if(j == len2) {
right_part_min = nums1[i];
} else {
right_part_min = nums1[i] < nums2[j]? nums1[i]:nums2[j];
}
return (left_part_max + right_part_min)/2.0;
}
};
【方法3】算法半岛主页
从题目可以知道,需要让我们在两个有序数组中找中位数。我们先分析一个有序数组的中位数,当有序数组的个数为奇数时,如nums=[1, 2, 3, 4, 5]
,该数组的中位数为nums[2]=3
;当有序数组的个数为偶数时,如nums=[1, 2, 3, 4, 5, 6]
,该数组的中位数为(nums[2]+nums[3])/2=3.5
。如图1所示,我们用同一公式可求出任意个数有序数组的中位数。
理解一个有序数组中位数求解过程后,对于两个有序数组来说,我们只要找出第(m+n+1)/2
大的数和第(m+n+2)/2
大的数,然后求平均数即可。注意这里的第(m+n+1)/2
大的数中m
和n
分别指两个数组的大小,m+n
如图1中的nums.length
,第(m+n+1)/2
大的数是指我们假设这两个数组组合成一个有序数组后找出第(m+n+1)/2
大的数(这里为什么没有像图1中进行减1?因为我们这里说的第几大的数下标是从1开始的;而图1中需要减1是因为使用的数组,下标是从0开始的)。
接下来我们在这两个有序数组中找到第(m+n+1)/2
大的数和第(m+n+2)/2
大的数,抽象后可表述为在两个有序数组中找第k大的数。由于题目要求我们的时间复杂度为O(log(m+n))
,我们很容易联想到二分查找。当查找时,我们还需要考虑一些特殊情况:(1) 当某个数组查找的起始位置大于等于该数组长度时,说明这个数组中的所有数已经被淘汰,则只需要在另一个数组找查找即可。(2)如果k=1
时,即需要查找第一个数,则找到两个数组起始位置中最小的那个即可。处理完特殊情况后,我们来分析一般情况。这里所说的二分是指对数组的大小进行二分还是指对k
进行二分。以前我们对一维数组进行二分查找时,一般都是对数组大小进行二分,而这里需要对k
进行二分。意思是,我们需要在两个数组查找第k/2
大的数,由于这两个数组的长度不定,有可能存在有一个数组中没有第k/2
大的数,如果没有则赋值为整型最大值。
- Java代码 -- 递归
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int m = nums1.length, n = nums2.length;
int l = (m + n + 1) / 2;
int r = (m + n + 2) / 2;
return (getKth(nums1, 0, nums2, 0, l) + getKth(nums1, 0, nums2, 0, r)) / 2.0;
}
// 在两个有序数组中二分查找第k大元素
private int getKth(int[] nums1, int start1, int[] nums2, int start2, int k){
// 特殊情况(1):当某个数组查找的起始位置大于等于该数组长度时,说明这个数组中的所有数已经被淘汰,则只需要在另一个数组找查找即可
if(start1 > nums1.length-1) return nums2[start2 + k - 1];
if(start2 > nums2.length-1) return nums1[start1 + k - 1];
// 特殊情况(2):如果k=1时,即需要查找第一个数,则找到两个数组起始位置中最小的那个即可
if(k == 1) return Math.min(nums1[start1], nums2[start2]);
// 分别在两个数组中查找第k/2个元素,若存在(即数组没有越界),标记为找到的值;若不存在,标记为整数最大值
int nums1Mid = start1 + k/2 - 1 < nums1.length ? nums1[start1 + k/2 - 1] : Integer.MAX_VALUE;
int nums2Mid = start2 + k/2 - 1 < nums2.length ? nums2[start2 + k/2 - 1] : Integer.MAX_VALUE;
// 确定最终的第k/2个元素,然后递归查找
if(nums1Mid < nums2Mid)
return getKth(nums1, start1 + k/2, nums2, start2, k-k/2);
else
return getKth(nums1, start1, nums2, start2 + k/2, k-k/2);
}
}
递归的层次比较深,如果数据足够大,用C++语言实现,可能会出现栈溢出,所以下面用了循环实现。
- C++代码实现 -- 循环
class Solution {
public:
int findkth1 (vector<int>& nums1, int start1, vector<int>& nums2, int start2, int k) {
while(k>1){
if(start1 >(int)(nums1.size()-1)) return nums2[start2 + k -1];
if(start2 >(int)(nums2.size()-1)) return nums1[start1 + k -1];
int nums1mid = start1 + k/2 -1 < nums1.size() ? nums1[start1 + k/2 -1] : INT_MAX;
int nums2mid = start2 + k/2 -1 < nums2.size() ? nums2[start2 + k/2 -1] : INT_MAX;
if(nums1mid > nums2mid) start2 += k/2;
else start1 += k/2;
k -= k/2; //比较之后,砍去了k/2个数,原先要找第k大,所以现在就要找第k - k/2大
}
if(start1 >(int)(nums1.size()-1)) return nums2[start2 + k -1];
if(start2 > (int)(nums2.size()-1)) return nums1[start1 + k -1];
if(1==k) return min(nums1[start1], nums2[start2]);
return 0.0;
}
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int m = nums1.size();
int n = nums2.size();
// add l and r to choose thr lst and rst large data(not the subscript)
int l = (m+n+1)/2;
int r = (m+n+2)/2;
return ((double)findkth1(nums1, 0, nums2, 0, l) + (double)findkth1(nums1, 0, nums2, 0, r))/2;
}
};