題目描述
給定兩個大小為 m 和 n 的有序數組 nums1 和 nums2。
請你找出這兩個有序數組的中位數,並且要求算法的時間復雜度為 O(log(m + n))。
你可以假設 nums1 和 nums2 不會同時為空。
示例 1:
nums1 = [1, 3]
nums2 = [2]
則中位數是 2.0
示例 2:
nums1 = [1, 2]
nums2 = [3, 4]
則中位數是 (2 + 3)/2 = 2.5
來源:力扣(LeetCode)
鏈接:https://leetcode-cn.com/problems/median-of-two-sorted-arrays
題解
我的題解:
我的思路:將兩個數組合並后排序,再找出中位數.
private static double findMedianSortedArrays(int[] nums1, int[] nums2) {
if (nums1.length==0&&nums2.length==0){
return 0;
}
double media = 0;
int[] both = new int[nums1.length+nums2.length];
System.arraycopy(nums1,0,both,0,nums1.length);
System.arraycopy(nums2,0,both,nums1.length,nums2.length);
Arrays.sort(both);
if (both.length%2==0){
media=(both[both.length/2-1]+both[both.length/2])/2.0;
} else {
media=both[both.length/2];
}
return media;
}
這里使用了java提供的API簡化了數組的合並和排序操作,有點取巧,但其實是不符合題目要求的,題目要求時間復雜度為O(log(m + n)),所以來看一下別人是怎么做的吧
官方題解:
思路:
為了解決這個問題,我們需要理解 “中位數的作用是什么”。在統計中,中位數被用來:
將一個集合划分為兩個長度相等的子集,其中一個子集中的元素總是大於另一個子集中的元素。
如果理解了中位數的划分作用,我們就很接近答案了。
首先,讓我們在任一位置 i 將 A 划分成兩個部分:
left_A | right_A
A[0], A[1], ..., A[i-1] | A[i], A[i+1], ..., A[m-1]
由於 A 中有 m 個元素, 所以我們有 m+1 種划分的方法(i=0∼m)。
我們知道:
len(left_A)=i,len(right_A)=m−i.
注意:當 i = 0 時,left_A 為空集, 而當 i = m時,right_A 為空集。
采用同樣的方式,我們在任一位置 j 將 B 划分成兩個部分:
left_B | right_B
B[0], B[1], ..., B[j-1] | B[j], B[j+1], ..., B[n-1]
將 left_A 和 left_B 放入一個集合,並將 right_A 和 right_B 放入另一個集合。 再把這兩個新的集合分別命名為 left_part 和 right_part:
left_part | right_part
A[0], A[1], ..., A[i-1] | A[i], A[i+1], ..., A[m-1]
B[0], B[1], ..., B[j-1] | B[j], B[j+1], ..., B[n-1]
如果我們可以確認:
len(left_part)=len(right_part)
max(left_part)≤min(right_part)
那么,我們已經將 {A,B} 中的所有元素划分為相同長度的兩個部分,且其中一部分中的元素總是大於另一部分中的元素。那么:
median= [max(left_part)+min(right_part)]/2
要確保這兩個條件,我們只需要保證:
ps.1 為了簡化分析,我假設 A[i−1],B[j−1],A[i],B[j] 總是存在,哪怕出現 i=0,i=m,j=0,或是 j=n 這樣的臨界條件。
我將在最后討論如何處理這些臨界值。
ps.2 為什么 n≥m?由於0≤i≤m 且 j=(m+n+1)/2−i,我必須確保 j 不是負數。如果 n<m,那么 j 將可能是負數,而這會造成錯誤的答案。
所以,我們需要做的是:
在 [0,m] 中搜索並找到目標對象 i,以使:
B[j−1]≤A[i] 且 A[i−1]≤B[j], 其中 j=(m+n+1)/2−i
接着,我們可以按照以下步驟來進行二叉樹搜索:
1.設 imin=0,imax=m, 然后開始在 [imin,imax] 中進行搜索。
2.令 i=(imin+imax)/2 , j=(m+n+1)/2−i
3.現在我們有 len(left_part)=len(right_part)。 而且我們只會遇到三種情況:
B[j−1]≤A[i] 且 A[i−1]≤B[j]:
這意味着我們找到了目標對象 i,所以可以停止搜索。
B[j−1]>A[i]:
這意味着 A[i] 太小,我們必須調整 i 以使 B[j−1]≤A[i]。
我們可以增大 i 嗎?
是的,因為當 i 被增大的時候,j 就會被減小。
因此 B[j−1] 會減小,而 A[i] 會增大,那么 B[j−1]≤A[i] 就可能被滿足。
我們可以減小 i 嗎?
不行,因為當 i 被減小的時候,j 就會被增大。
因此 B[j−1] 會增大,而 A[i] 會減小,那么 B[j−1]≤A[i] 就可能不滿足。
所以我們必須增大 i。也就是說,我們必須將搜索范圍調整為 [i+1,imax]。
因此,設 imin=i+1,並轉到步驟 2。
A[i−1]>B[j]:
這意味着 A[i−1] 太大,我們必須減小 i 以使 A[i−1]≤B[j]。
也就是說,我們必須將搜索范圍調整為 [imin,i−1]。
因此,設 imax=i−1,並轉到步驟 2。
當找到目標對象 i 時,中位數為:max(A[i−1],B[j−1]), 當 m+n 為奇數時
[max(A[i−1],B[j−1])+min(A[i],B[j])]/2
, 當 m + n 為偶數時
現在,讓我們來考慮這些臨界值 i=0,i=m,j=0,j=n,此時 A[i−1],B[j−1],A[i],B[j] 可能不存在。
其實這種情況比你想象的要容易得多。
我們需要做的是確保 max(left_part)≤min(right_part)。 因此,如果 i 和 j 不是臨界值(這意味着 A[i−1],B[j−1],A[i],B[j] 全部存在), 那么我們必須同時檢查 B[j−1]≤A[i] 以及 A[i−1]≤B[j] 是否成立。
但是如果 ]A[i−1],B[j−1],A[i],B[j] 中部分不存在,那么我們只需要檢查這兩個條件中的一個(或不需要檢查)。
舉個例子,如果 i = 0,那么 A[i−1] 不存在,我們就不需要檢查 A[i−1]≤B[j] 是否成立。
所以,我們需要做的是:
在 [0,m] 中搜索並找到目標對象 i,以使:
(j=0 or i = m or B[j−1]≤A[i]) 或是
i=0 or j = n or A[i−1]≤B[j]), 其中 j = (m+n+1)/2−i
在循環搜索中,我們只會遇到三種情況:
j=0 or i=m or B[j−1]≤A[i]) 或是 i=0 or j=n or A[i−1]≤B[j]),這意味着 i 是完美的,我們可以停止搜索。
j>0 and i<m and B[j−1]>A[i] 這意味着 i 太小,我們必須增大它。
i>0 and j<n and A[i−1]>B[j] 這意味着 ii 太大,我們必須減小它。
i<m⟹j>0 以及 i>0⟹j<n 始終成立,這是因為:
所以,在情況 2 和 3中,我們不需要檢查 j > 0 或是 j < n 是否成立。
public double findMedianSortedArrays(int[] A, int[] B) {
int m = A.length;
int n = B.length;
if (m > n) { // to ensure m<=n
int[] temp = A; A = B; B = temp;
int tmp = m; m = n; n = tmp;
}
int iMin = 0, iMax = m, halfLen = (m + n + 1) / 2;
while (iMin <= iMax) {
int i = (iMin + iMax) / 2;
int j = halfLen - i;
if (i < iMax && B[j-1] > A[i]){
iMin = i + 1; // i is too small
}
else if (i > iMin && A[i-1] > B[j]) {
iMax = i - 1; // i is too big
}
else { // i is perfect
int maxLeft = 0;
if (i == 0) { maxLeft = B[j-1]; }
else if (j == 0) { maxLeft = A[i-1]; }
else { maxLeft = Math.max(A[i-1], B[j-1]); }
if ( (m + n) % 2 == 1 ) { return maxLeft; }
int minRight = 0;
if (i == m) { minRight = B[j]; }
else if (j == n) { minRight = A[i]; }
else { minRight = Math.min(B[j], A[i]); }
return (maxLeft + minRight) / 2.0;
}
}
return 0.0;
}
覺得不易理解?更多題解訪問:https://leetcode-cn.com/problems/median-of-two-sorted-arrays