描述：
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)).
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
翻译过来就是，给定两个已经升序排序过的数组，求这两个数组的中位数；中位数的定义为把两个数组合并过后进行升序排序后，处于数组中间的那个数，此时如果合并后的数组元素个数为偶数，则为中间两个数的平均值。
初看起来这就是个寻找第k小数的问题，解决方案有很多，最简单的就是采用归并排序的思想把两个数组进行合并，然后取中间的数就可以了。但问题在于，这个题目限定了时间复杂度为O(log(m+n))，而合并算法的时间复杂度为O(nlogn)，显然不合题意。另外一个方法是设置一个双指针，一开始都指向两个数组的开头，不停地比较两个指针指向的元素的大小，指向小元素的指针的往前移一个元素去追指向大元素的指针，一直移动(len1+len2)/2次后就能得到中位数，但是这个算法的时间复杂度仍然不符合题意，为O(n)
但是注意到这个题目给定的数组已经是排过序的了，算法导论中对order statistic问题进行过讨论，因此，在有序又要求log级的时间复杂度，可以考虑分治策略，采用二分法。
大方向定好了，但是并不清楚具体要怎么去完成这个二分法，我们应该对什么去做二分？其实这个题目需要找的就是第k小的元素问题，假设我们的第k小的数是在第一个数组中找了p次，然后在第二个数组中找了q次，那么满足关系：p+q=k。进一步的，寻找第k小的数的过程就是寻找p和q的过程，k我们是知道的，但是p和q是不知道的，因此事实上我们的目标就是去搜索p(找到了p就等于找到了q)，因此我们二分法的目标，事实上就是二分k来找p。
我们先定义以下形式的函数用来寻找第k小的数：
findKth(nums1, nums2, start1, len1, start2, len2, k)
nums1和nums2表示原始的两个数组，start1、len1表示nums1数组中以start1位置开始、len1长度的一个子数组；start2、lens2表示nums2数组中以start2位置开始、len2长度的一个子数组；k表示从这两个子数组中找到第k小的数。之所以提供start1、len1、start2、len2，是因为经验告诉我们分治法解决问题都是递归的，我们在二分的时候就需要记录这些相关的数据。
我们的外层入口就应该是这样子的：
if(len1+len2是偶数) {
return (findKth(nums1, nums2, 0, len1, 0, len2, (len1+len2)/2) +
findKth(nums1, nums2, 0, len1, 0, len2, (len1+len2)/2 + 1)) / 2;
}
else {
return findKth(nums1, nums2, 0, len1, 0, len2 (len1+len2)/2);
}
下面就是具体对于findKth的实现了。
首先，我们知道，我们需要对k进行二分：
findKth(nums1, nums2, start1, len1, start2, len2, k) {
p = k / 2;
}
这个p怎么用呢？假设我们在nums1中取nums1[start1+p-1]，就表示我们在nums1中“前进”了p个元素，且这p个元素是有序的，相应的，q = k - p，我们需要在nums2中前进q个元素：
findKth(nums1, nums2, start1, len1, start2, len2, k) {
p = k / 2;
q = k - p;
}
假如这个时候nums1[start1 + p - 1]等于nums2[start + q - 1]，这说明kth = nums1[start1 + p - 1] = nums2[start + q - 1] = 第k小的数，为什么呢？这里要注意nums1和nums2都是有序的，因此它们的子数组也是有序的；假设把两个子数组数组合并，那么在nums1子数组中排在kth前面的数在合并后的数组中一定还是排在kth前面，同理在nums2子数组中排在kth前面的数在合并后的数组中也一定还是排在kth前面，它们的具体顺序我们不关心也不必关心，我们只需要知道这样一来在合并后的数组中就有p-1+q-1=k-2个数在kth前面，因此kth一定就是第k小的那个数。
如果nums1[start1 + p - 1]大于nums2[start + q - 1]，这里就出现了一个需要注意的情况，这意味着nums2子数组中的前q个数一定都是小于nums1[start1 + p - 1]的(再次注意，nums1和nums2都是有序的)，而q
findKth(nums1, nums2, start1, len1, start2, len2, k) {
p = k / 2;
q = k - p;
if(nums1[start1 + p - 1] == nums2[start2 + q - 1]) {
return nums1[start1 + p - 1];
}
else if(nums1[start1 + p - 1] > nums2[start2 + q - 1]) {
return findKth(nums1, nums2, start1, len1, start2 + q, len2 - q, k - q);
}
else if(nums1[start1 + p - 1] < nums2[start2 + q - 1]) {
return findKth(nums1, nums2, start1 + p, len1 - p, start2, len2, k - p);
}
}
上面的框架大致已经描述清楚了我们的二分搜索算法，下一步就需要考虑退出条件。
退出条件有这么一些：
在某一步搜索中子数组的长度为0了，这表示有一个数组中的元素完全被抛弃掉，此时另外一个子数组的第k个元素就是我们要求的第k小的元素；
在不满足1的情况下，出现k=1的情况，这表示需要在两个子数组中找第1小的元素，此时简单地比较一下两个子数组的第一个元素就行了；
nums1[start1 + p - 1] == nums2[start2 + q - 1]
因此可以进一步写成：
findKth(nums1, nums2, start1, len1, start2, len2, k) {
if(某个子数组的长度为零) {
return 另外一个子数组的第k个元素;
}
if(k == 1) {
return min(nums1[start1], nums2[start2]);
}
p = k / 2;
q = k - p;
if(nums1[start1 + p - 1] == nums2[start2 + q - 1]) {
return nums1[start1 + p - 1];
}
else if(nums1[start1 + p - 1] > nums2[start2 + q - 1]) {
return findKth(nums1, nums2, start1, len1, start2 + q, len2 - q, k - q);
}
else if(nums1[start1 + p - 1] < nums2[start2 + q - 1]) {
return findKth(nums1, nums2, start1 + p, len1 - p, start2, len2, k - p);
}
}
为了方便考虑问题，不失一般性，我们要求nums1永远是那个长度较短的数组：
findKth(nums1, nums2, start1, len1, start2, len2, k) {
if(len1 > len2) {
return findKth(nums2, nums1, start2, len2, start2, start1);
}
if(len1 == 0) {
return nums2[start2 + k - 1];
}
if(k == 1) {
return min(nums1[start1], nums2[start2]);
}
p = k / 2;
q = k - p;
if(nums1[start1 + p - 1] == nums2[start2 + q - 1]) {
return nums1[start1 + p - 1];
}
else if(nums1[start1 + p - 1] > nums2[start2 + q - 1]) {
return findKth(nums1, nums2, start1, len1, start2 + q, len2 - q, k - q);
}
else if(nums1[start1 + p - 1] < nums2[start2 + q - 1]) {
return findKth(nums1, nums2, start1 + p, len1 - p, start2, len2, k - p);
}
}
此外还有一个容易被忽略的边界问题，那就是p=k/2这一句，如果p大于len1的话，就会出现越界访问的问题，这个时候需要对其进行控制：
findKth(nums1, nums2, start1, len1, start2, len2, k) {
if(len1 > len2) {
return findKth(nums2, nums1, start2, len2, start2, start1);
}
if(len1 == 0) {
return nums2[start2 + k - 1];
}
if(k == 1) {
return min(nums1[start1], nums2[start2]);
}
p = min(k / 2, len1);
q = k - p;
if(nums1[start1 + p - 1] == nums2[start2 + q - 1]) {
return nums1[start1 + p - 1];
}
else if(nums1[start1 + p - 1] > nums2[start2 + q - 1]) {
return findKth(nums1, start1, len1, start2 + q, len2 - q, k - q);
}
else if(nums1[start1 + p - 1] > nums2[start2 + q - 1]) {
return findKth(nums1, start1 + p, len1 - p, start2, len2, k - p);
}
}
分析到这里，基本上这个问题就解决了，不过需要说的是，对于p=min(k/2,len1)这一句，这里看起来应该就是二分法的比较关键的一个地方了，事实上我们把2换成3、4、5、6……都是可以的，因为二分法搜索事实上就是个碰运气的过程，不过需要注意的是，这里p不能为0，否则在nums1中等于是没有做“前进”的动作，这是不允许的，因此更加健壮的描述应该为：
p = min(max(k/2, 1), len1);
即二分过程中，每一次迭代至少要在nums1中“前进”一步。
整个程序的C++代码如下：
#include
class Solution {
private:
double findKth(vector& nums1, vector& nums2, int start1, int len1, int start2, int len2, int k) {
if (len1 > len2) {
return findKth(nums2, nums1, start2, len2, start1, len1, k);
}
if (len1 == 0) {
return nums2[start2 + k - 1];
}
if (k == 1) {
return min(nums1[start1], nums2[start2]);
}
int p1 = min(k / 2, len1);
int p2 = k - p1;
if (nums1[start1 + p1 - 1] > nums2[start2 + p2 - 1]) {
return findKth(nums1, nums2, start1, len1, start2 + p2, len2 - p2, k - p2);
}
else if(nums1[start1 + p1 - 1] < nums2[start2 + p2 - 1]){
return findKth(nums1, nums2, start1 + p1, len1 - p1, start2, len2, k - p1);
}
else {
return nums1[start1 + p1 - 1];
}
}
public:
double findMedianSortedArrays(vector& nums1, vector& nums2) {
int len = nums1.size() + nums2.size();
if (!(len & 0x01)) {
return (findKth(nums1, nums2, 0, nums1.size(), 0, nums2.size(), len / 2)
+ findKth(nums1, nums2, 0, nums1.size(), 0, nums2.size(), len / 2 + 1)
) / 2.0f;
}
else {
return findKth(nums1, nums2, 0, nums1.size(), 0, nums2.size(), len / 2 + 1);
}
}
};
279
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
