LeetCode 4. Median of Two Sorted Arrays的两种思路

题目链接

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

首先，看到是两个已经排好序的数组，自然想到最直接简单的方法，就是归并排序，再得到中值。显然这样的时间复杂度是O(m+n)的。代码实现如下：

class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int size = nums1.size() + nums2.size();
if (size == 0)
return 0;
int count = 0, i = 0, j = 0;
while (count < (size - 1) / 2) {
if (i >= nums1.size())
j++;
else if (j >= nums2.size())
i++;
else if (nums1[i] < nums2[j])
i++;
else
j++;
count++;
}
double median = 0;
if (size % 2 == 0) {
for (int k = 0; k < 2; k++) {
if (i >= nums1.size()) {
median += nums2[j];
j++;
}
else if (j >= nums2.size()) {
median += nums1[i];
i++;
}
else if (nums1[i] < nums2[j]) {
median += nums1[i];
i++;
}
else {
median += nums2[j];
j++;
}
}
median /= 2;
}
else {
if (i >= nums1.size())
median = nums2[j];
else if (j >= nums2.size())
median = nums1[i];
else if (nums1[i] < nums2[j])
median = nums1[i];
else
median = nums2[j];
}
return median;
}
};

虽然思路简单，但是由于两个数组的长度是不定的，因此需要很多的条件判断。

另一种思路，可以利用分治的方法。例如现在有数组A，B：

___ ___ ___ ___ ___
A: | a | b | c | d | e |
--- --- --- --- ---
___ ___ ___
B: | x | y | z |
--- --- ---

我们得到A+B的中值，可以分别先得到A的中值c和B的中值y。那么c和y有三种关系。我们以c<y为例，我们在下一次分治的时候，只需要处理c,d,e和x,y即可。原因很简单，当c<y，那么有a<b<c<y<z和a<b<c<d<e，即我们可以简单的理解为这样一个理论：分别根据A，B的中值，将A分为A1，A2，将B分为B1，B2。那么，在这种情况下，显然有A1<A2，A1<B2，B1<B2，即总体被分成了四部分，且A2和B1组成了中间的两部分，而A1和B2分别是首尾的两部分。即最后的中值，必定不会在A1和B2中，于是可以将它们舍去。

然而，其实这个思路实现起来很繁琐（至少对我而言），因为太多的边界条件需要判断，元素总数的奇偶性也造成了很大的麻烦。

于是。在此基础上，我们可以退一步，利用求第K小数的思路来解题。在上例中，假设c=A[k/2-1]，y=B[k/2-1]，那么同样，A1这部分是可以舍去的 ，但是B2则不能。这样，虽然每次问题规模缩小的幅度没有上面的方法大，但是实现起来却方便得多。因为k的奇偶性问题可以很方便解决，且边界判定也少了很多麻烦。代码实现如下：

class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int size = nums1.size() + nums2.size();
deque<int> que1, que2;
for (int i = 0; i < nums1.size(); i++)
que1.push_back(nums1[i]);
for (int i = 0; i < nums2.size(); i++)
que2.push_back(nums2[i]);
if (size % 2 == 0) {
deque<int> que3(que1), que4(que2);
double x = getKsmallest(que1, que2, size / 2);
double y = getKsmallest(que3, que4, size / 2 + 1);
return (x + y) / 2;
}
else {
return getKsmallest(que1, que2, size / 2 + 1);
}
}

double getKsmallest(deque<int>& que1, deque<int>& que2, int k) {
int m = que1.size(), n = que2.size();
if (m > n)
return getKsmallest(que2, que1, k);
if (m == 0)
return que2[k - 1];
if (k == 1) {
return min(que1[0], que2[0]);
}
int index1 = min(k / 2, m) - 1, index2 = k - index1 - 1 - 1;
if (que1[index1] < que2[index2]) {
int x = 0;
while (x++ < index1 + 1)
que1.pop_front();
return getKsmallest(que1, que2, k - index1 - 1);
}
else if (que1[index1] > que2[index2]) {
int y = 0;
while (y++ < index2 + 1)
que2.pop_front();
return getKsmallest(que1, que2, k - index2 - 1);
}
else {
return que1[index1];
}

}

};

同时，这样也将时间复杂度降低到了O(log(m + n))