4. Median of Two Sorted Arrays (H)
https://leetcode.com/problems/median-of-two-sorted-arrays/
Given two sorted arrays nums1
and nums2
of size m
and n
respectively, return the median of the two sorted arrays.
The overall run time complexity should be O(log (m+n))
.
Example 1:
Input: nums1 = [1,3], nums2 = [2]
Output: 2.00000
Explanation: merged array = [1,2,3] and median is 2.
Example 2:
Input: nums1 = [1,2], nums2 = [3,4]
Output: 2.50000
Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
Constraints:
nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106
Solution:
Version 1: Divided+Conquer
分治法。时间复杂度 log(n+m)log(n+m)
public class Solution {
public double findMedianSortedArrays(int A[], int B[]) {
int n = A.length + B.length;
if (n % 2 == 0) {
return (
findKth(A, 0, B, 0, n / 2) +
findKth(A, 0, B, 0, n / 2 + 1)
) / 2.0;
}
return findKth(A, 0, B, 0, n / 2 + 1);
}
// find kth number of two sorted array
public static int findKth(int[] A, int startOfA,
int[] B, int startOfB,
int k){
if (startOfA >= A.length) {
return B[startOfB + k - 1];
}
if (startOfB >= B.length) {
return A[startOfA + k - 1];
}
if (k == 1) {
return Math.min(A[startOfA], B[startOfB]);
}
int halfKthOfA = startOfA + k / 2 - 1 < A.length
? A[startOfA + k / 2 - 1]
: Integer.MAX_VALUE;
int halfKthOfB = startOfB + k / 2 - 1 < B.length
? B[startOfB + k / 2 - 1]
: Integer.MAX_VALUE;
if (halfKthOfA < halfKthOfB) {
return findKth(A, startOfA + k / 2, B, startOfB, k - k / 2);
} else {
return findKth(A, startOfA, B, startOfB + k / 2, k - k / 2);
}
}
}
Version 2: Binary Search
二分答案的方法,时间复杂度 O(log(range)∗(log(n)+log(m)))O(log(range)∗(log(n)+log(m)))
其中 range 为最小和最大的整数之间的范围。 可以拓展到 Median of K Sorted Arrays
public class Solution {
/*
* @param A: An integer array
* @param B: An integer array
* @return: a double whose format is *.5 or *.0
*/
public double findMedianSortedArrays(int[] A, int[] B) {
int n = A.length + B.length;
if (n % 2 == 0) {
return (findKth(A, B, n / 2) + findKth(A, B, n / 2 + 1)) / 2.0;
}
return findKth(A, B, n / 2 + 1);
}
// k is not zero-based, it starts from 1
public int findKth(int[] A, int[] B, int k) {
if (A.length == 0) {
return B[k - 1];
}
if (B.length == 0) {
return A[k - 1];
}
int start = Math.min(A[0], B[0]);
int end = Math.max(A[A.length - 1], B[B.length - 1]);
// find first x that >= k numbers is smaller or equal to x
while (start + 1 < end) {
int mid = start + (end - start) / 2;
if (countSmallerOrEqual(A, mid) + countSmallerOrEqual(B, mid) < k) {
start = mid;
} else {
end = mid;
}
}
if (countSmallerOrEqual(A, start) + countSmallerOrEqual(B, start) >= k) {
return start;
}
return end;
}
private int countSmallerOrEqual(int[] arr, int number) {
int start = 0, end = arr.length - 1;
// find first index that arr[index] > number;
while (start + 1 < end) {
int mid = start + (end - start) / 2;
if (arr[mid] <= number) {
start = mid;
} else {
end = mid;
}
}
if (arr[start] > number) {
return start;
}
if (arr[end] > number) {
return end;
}
return arr.length;
}
}
Last updated
Was this helpful?