题目
解法一:遍历
由于两个数组的长度已知,因此中位数对应的两个数组的下标之和也是已知的。维护两个指针,初始时分别指向两个数组的下标 0 的位置,每次将指向较小值的指针后移一位(如果一个指针已经到达数组末尾,则只需要移动另一个数组的指针),直到到达中位数的位置。
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int m = nums1.length;
int n = nums2.length;
int t = m + n;
int pre = -1, cur = -1;
int i = 0, j = 0;
for (int k = 0; k <= t/2; k++) {
pre = cur;
if (i == m) {
cur = nums2[j++];
} else if (j == n) {
cur = nums1[i++];
} else {
if (nums1[i] < nums2[j]) {
cur = nums1[i++];
} else {
cur = nums2[j++];
}
}
}
if (t%2 == 0) {
return (pre + cur) / 2.0;
} else {
return cur;
}
}
}
- 时间复杂度: O ( m + n ) O(m +n) O(m+n)
- 空间复杂度: O ( 1 ) O(1) O(1)
解法二:二分查找
根据中位数的定义,当 m + n m+n m+n 是奇数时,中位数是两个有序数组中的第 ( m + n ) / 2 (m+n)/2 (m+n)/2 个元素,当 m + n m+n m+n 是偶数时,中位数是两个有序数组中的第 ( m + n ) / 2 (m+n)/2 (m+n)/2 个元素和第 ( m + n ) / 2 + 1 (m+n)/2+1 (m+n)/2+1 个元素的平均值。因此,本题可以转化成寻找两个有序数组中的第 k k k 小的数,其中 k k k 为 ( m + n ) / 2 (m+n)/2 (m+n)/2 或 ( m + n ) / 2 + 1 (m+n)/2+1 (m+n)/2+1。
假设两个有序数组分别是 A \text{A} A 和 B \text{B} B。要找到第 k k k 小的数,可以比较 A [ k / 2 − 1 ] \text{A}[k/2-1] A[k/2−1] 和 B [ k / 2 − 1 ] \text{B}[k/2-1] B[k/2−1],其中 / / / 表示整数除法。由于 A [ k / 2 − 1 ] \text{A}[k/2-1] A[k/2−1] 和 B [ k / 2 − 1 ] \text{B}[k/2-1] B[k/2−1] 的前面分别有 A [ 0 . . k / 2 − 2 ] \text{A}[0\,..\,k/2-2] A[0..k/2−2] 和 B [ 0 . . k / 2 − 2 ] \text{B}[0\,..\,k/2-2] B[0..k/2−2],即 k / 2 − 1 k/2-1 k/2−1 个元素,对于 A [ k / 2 − 1 ] \text{A}[k/2-1] A[k/2−1] 和 B [ k / 2 − 1 ] \text{B}[k/2-1] B[k/2−1]中的较小值,最多只会有 ( k / 2 − 1 ) + ( k / 2 − 1 ) ≤ k − 2 (k/2-1)+(k/2-1) \leq k-2 (k/2−1)+(k/2−1)≤k−2个元素比它小,那么它就不能是第 k k k 小的数了。
因此可以归纳出三种情况:
-
如果 A [ k / 2 − 1 ] < B [ k / 2 − 1 ] \text{A}[k/2-1] < \text{B}[k/2-1] A[k/2−1]<B[k/2−1],则比 A [ k / 2 − 1 ] \text{A}[k/2-1] A[k/2−1] 小的数最多只有 A \text{A} A 的前 k / 2 − 1 k/2−1 k/2−1 个数和 B \text{B} B 的前 k / 2 − 1 k/2−1 k/2−1 个数,即比 A [ k / 2 − 1 ] \text{A}[k/2-1] A[k/2−1] 小的数最多只有 k − 2 k-2 k−2 个,因此 A [ k / 2 − 1 ] \text{A}[k/2-1] A[k/2−1] 不可能是第 k k k 个数, A [ 0 ] \text{A}[0] A[0] 到 A [ k / 2 − 1 ] \text{A}[k/2-1] A[k/2−1] 也都不可能是第 k k k 个数,可以全部排除。
-
如果 A [ k / 2 − 1 ] > B [ k / 2 − 1 ] \text{A}[k/2-1] > \text{B}[k/2-1] A[k/2−1]>B[k/2−1],则可以排除 B [ 0 ] \text{B}[0] B[0] 到 B [ k / 2 − 1 ] \text{B}[k/2-1] B[k/2−1]。
-
如果 A [ k / 2 − 1 ] = B [ k / 2 − 1 ] \text{A}[k/2-1] = \text{B}[k/2-1] A[k/2−1]=B[k/2−1],则可以归入第一种情况处理(也可以归入第二种情况处理)
二分查找只有一个思想,那就是:逐步缩小搜索区间
可以看到,**比较 A [ k / 2 − 1 ] \text{A}[k/2-1] A[k/2−1] 和 B [ k / 2 − 1 ] \text{B}[k/2-1] B[k/2−1] 之后,可以排除 k / 2 k/2 k/2 个不可能是第 k k k 小的数,查找范围缩小了一半。**同时,将在排除后的新数组上继续进行二分查找,并且根据排除数的个数,减少 k k k 的值,这是因为排除的数都不大于第 k k k 小的数。
有以下三种情况需要特殊处理:
-
如果 A [ k / 2 − 1 ] \text{A}[k/2-1] A[k/2−1] 或者 B [ k / 2 − 1 ] \text{B}[k/2-1] B[k/2−1] 越界,那么可以选取对应数组中的最后一个元素。在这种情况下,必须根据排除数的个数减少 k k k 的值,而不能直接将 k k k 减去 k / 2 k/2 k/2。
-
如果一个数组为空,说明该数组中的所有元素都被排除,可以直接返回另一个数组中第 k k k 小的元素
-
如果 k = 1 k=1 k=1,只要返回两个数组首元素的最小值即可
class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int length1 = nums1.length, length2 = nums2.length;
int totalLength = length1 + length2;
if (totalLength % 2 == 1) {
int midIndex = totalLength / 2;
double median = getKthElement(nums1, nums2, midIndex + 1);
return median;
} else {
int midIndex1 = totalLength / 2 - 1, midIndex2 = totalLength / 2;
double median = (getKthElement(nums1, nums2, midIndex1 + 1) + getKthElement(nums1, nums2, midIndex2 + 1)) / 2.0;
return median;
}
}
public int getKthElement(int[] nums1, int[] nums2, int k) {
/* 主要思路:要找到第 k (k>1) 小的元素,那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
* 这里的 "/" 表示整除
* nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
* nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
* 取 pivot = min(pivot1, pivot2),两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
* 这样 pivot 本身最大也只能是第 k-1 小的元素
* 如果 pivot = pivot1,那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除",剩下的作为新的 nums1 数组
* 如果 pivot = pivot2,那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除",剩下的作为新的 nums2 数组
* 由于我们 "删除" 了一些元素(这些元素都比第 k 小的元素要小),因此需要修改 k 的值,减去删除的数的个数
*/
int length1 = nums1.length, length2 = nums2.length;
// 排除部分元素后,指向两个数组剩余元素的首元素
int index1 = 0, index2 = 0;
int kthElement = 0;
while (true) {
// 边界情况
// index1 == length1 表明 nums1 中的元素全部排除,返回 nums2 中第k小的元素
if (index1 == length1) {
return nums2[index2 + k - 1];
}
// index2 == length2 表明 nums2 中的元素全部排除,返回 nums1 中第k小的元素
if (index2 == length2) {
return nums1[index1 + k - 1];
}
if (k == 1) {
// k == 1 此时两数组首元素的最小值即为要找的第k小值
return Math.min(nums1[index1], nums2[index2]);
}
// 正常情况
int half = k / 2;
// Math.min(index1 + half, length1) 取两者最小值的原因是为了防止数组越界
int newIndex1 = Math.min(index1 + half, length1) - 1;
int newIndex2 = Math.min(index2 + half, length2) - 1;
// A[k/2 - 1] B[k/2 - 1]
int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];
// 比较 A[k/2 - 1] 与 B[k/2 - 1]
if (pivot1 <= pivot2) {
// 排除掉 A[index1, newIndex1] 这 newIndex1 - index1 + 1 个元素
k -= (newIndex1 - index1 + 1);
index1 = newIndex1 + 1;
} else {
// 排除掉 B[index2, newIndex2] 这 newIndex2 - index2 + 1 个元素
k -= (newIndex2 - index2 + 1);
index2 = newIndex2 + 1;
}
}
}
}
- 时间复杂度: O ( log ( m + n ) ) O(\log(m+n)) O(log(m+n)),其中 m m m 和 n n n 分别是数组 nums 1 \textit{nums}_1 nums1 和 nums 2 \textit{nums}_2 nums2 的长度。初始时有 k = ( m + n ) / 2 k=(m+n)/2 k=(m+n)/2 或 k = ( m + n ) / 2 + 1 k=(m+n)/2+1 k=(m+n)/2+1,每一轮循环可以将查找范围减少一半,因此时间复杂度是 O ( log ( m + n ) ) O(\log(m+n)) O(log(m+n))。
- 空间复杂度: O ( 1 ) O(1) O(1)