LeetCode.H4
题目:
题目大意:
给定两个升序数组,求这两个数组合并后的中位数。时间复杂度要求为O(log(n + m))。
数据范围:
如图所示
思路:
根据中位数的定义:
-
当 m + n 是奇数时,中位数是两个有序数组中的第 (m + n + 1) / 2 个元素。
-
当 m + n 是偶数时,中位数是两个有序数组中的第 (m + n + 1) / 2 个元素和第 (m + n + 2) / 2 个元素的平均值。
特别注意,当 m + n 是奇数时,第 (m + n + 1) / 2 个元素和第 (m + n + 2) / 2 是同一个元素,因此,我们不管 m + n 是奇数还是偶数,只要求出第 (m + n + 1) / 2 个元素和第 (m + n + 2) / 2 个元素的和的平均值,该值即为我们要求的中位数。
因为我们时间复杂度要求是O(log(n + m))的,可以想到用“二分”来做,即每次处理只处理一半的区间。
假设两个有序数组分别是 A 和 B。要找到第 k 个元素,我们可以比较 A[k / 2 − 1] 和 B[k / 2 − 1],其中 / 表示整数除法。由于 A[k / 2 − 1] 和 B[k / 2 − 1] 的前面分别有 A[0…k / 2 − 2] 和 B[0…k / 2 − 2],即 k / 2 − 1 个元素,对于 A[k / 2 − 1] 和 B[k / 2 − 1] 中的较小值,最多只会有 (k / 2 - 1)+(k / 2 - 1) ≤ k − 2 个元素比它小,那么它就不能是第 k 小的数了(最多是第k - 1小的数)。因此就可以抛弃该较小值和它前面的数。
因此我们可以归纳出三种情况:
-
如果 A[k / 2 − 1]<B[k / 2 − 1],则比 A[k / 2 − 1] 小的数最多只有 A 的前 k / 2 − 1 个数和 B 的前 k / 2 − 1 个数,即比 A[k / 2 − 1] 小的数最多只有 k − 2 个,因此 A[k / 2 − 1] 不可能是第 k 个数,A[0] 到 A[k / 2 − 1] 也都不可能是第 k 个数,可以全部排除。
-
如果 A[k / 2 − 1]>B[k / 2 − 1],则可以排除 B[0] 到 B[k / 2 − 1]的数。
-
如果 A[k / 2 − 1]=B[k / 2 − 1],则可以归入第一种情况处理。
有以下三种情况需要特殊处理:
-
如果 A[k / 2 − 1] 或者 B[k / 2 − 1] 越界,那么我们可以选取对应数组中的最后一个元素。在这种情况下,我们必须根据排除数的个数减少 k 的值,而不能直接将 k 减去 k / 2。
-
如果一个数组为空,说明该数组中的所有元素都被排除,我们可以直接返回另一个数组中第 k 小的元素。
-
如果 k = 1,我们只要返回两个数组首元素的最小值即可。
用一个例子说明上述算法。假设两个有序数组如下:
A: 1 3 4 9
B: 1 2 3 4 5 6 7 8 9
两个有序数组的长度分别是 4 和 9,长度之和是 13,中位数是两个有序数组中的第 7 个元素,因此需要找到第 k = 7 个元素。
比较两个有序数组中下标为 k / 2 − 1 = 2 的数,即 A[2] 和 B[2],如下面所示:
A: 1 3 4 9
↑
B: 1 2 3 4 5 6 7 8 9
↑
由于A[2] > B[2],因此排除 B[0] 到 B[2],即数组 B 的下标偏移变为 3,同时更新 k 的值:k = k − k / 2 = 4。
下一步寻找,比较两个有序数组中下标为 k / 2 − 1 = 1 的数,即 A[1] 和 B[4],如下面所示,其中方括号部分表示已经被排除的数。
A: 1 3 4 9
↑
B: [1 2 3] 4 5 6 7 8 9
↑
由于 A[1]<B[4],因此排除 A[0] 到 A[1],即数组 A 的下标偏移变为 2,同时更新 k 的值:k = k − k / 2 = 2。
下一步寻找,比较两个有序数组中下标为 k / 2 − 1 = 0 的数,即比较 A[2] 和 B[3],如下面所示,其中方括号部分表示已经被排除的数。
A: [1 3] 4 9
↑
B: [1 2 3] 4 5 6 7 8 9
↑
由于A[2] = B[3],根据之前的规则,排除 A 中的元素,因此排除 A[2],即数组 A 的下标偏移变为 3,同时更新 k 的值:k = k − k / 2 = 1。
由于 k 的值变成 1,因此比较两个有序数组中的未排除下标范围内的第一个数,其中较小的数即为第 k 个数,由于A[3] > B[3],因此第 k 个数是 B[3] = 4。
A: [1 3 4] 9
↑
B: [1 2 3] 4 5 6 7 8 9
↑
代码:
class Solution {
public double getKthNum(int[] nums1, int[] nums2, int k){
int i = 0, j = 0;
while (true){
if (i >= nums1.length)
return nums2[j + k - 1];
if (j >= nums2.length)
return nums1[i + k - 1];
if (k == 1)
return Math.min(nums1[i], nums2[j]);
int half = k / 2;
int idx1 = Math.min(i + half - 1, nums1.length - 1);
int idx2 = Math.min(j + half - 1, nums2.length - 1);
int p1 = nums1[idx1], p2 = nums2[idx2];
if (p1 <= p2){
k -= (idx1 - i + 1);
i = idx1 + 1;
}else {
k -= (idx2 - j + 1);
j = idx2 + 1;
}
}
}
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int n = nums1.length, m = nums2.length;
double a = getKthNum(nums1, nums2, (n + m + 1) / 2);
double b = getKthNum(nums1, nums2, (n + m + 2) / 2);
return (a + b) / 2;
}
}
public class Main {
public static void main(String[] args) {
Solution solution = new Solution();
int[] nums1 = new int[]{1,2};
int[] nums2 = new int[]{3,4};
System.out.println(solution.findMedianSortedArrays(nums1, nums2));
}
}
时空复杂度分析等:
-
时间复杂度 : O(log(n + m)),m、n为数组长度。
-
空间复杂度 : O(1)。