尋找兩個有序數組中的中位數

1.題目描述

給定兩個大小爲 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

2.問題解析

方法：遞歸法

爲了解決這個問題，咱們須要理解「中位數的做用是什麼」。在統計中，中位數被用來：

將一個集合劃分爲兩個長度相等的子集，其中一個子集中的元素老是大於另外一個子集中的元素。
若是理解了中位數的劃分做用，咱們就很接近答案了。

首先，讓咱們在任一位置 ii 將 \text{A}A 劃分紅兩個部分：

          left_A             |        right_A
    A[0], A[1], ..., A[i-1]  |  A[i], A[i+1], ..., A[m-1]
因爲 \text{A}A 中有 mm 個元素， 因此咱們有 m+1m+1 種劃分的方法（i = 0 \sim mi=0∼m）。

咱們知道：

\text{len}(\text{left\_A}) = i, \text{len}(\text{right\_A}) = m - ilen(left_A)=i,len(right_A)=m−i.

注意：當 i = 0i=0 時，\text{left\_A}left_A 爲空集， 而當 i = mi=m 時, \text{right\_A}right_A 爲空集。
採用一樣的方式，咱們在任一位置 jj 將 \text{B}B 劃分紅兩個部分：


          left_B             |        right_B
    B[0], B[1], ..., B[j-1]  |  B[j], B[j+1], ..., B[n-1]
將 \text{left\_A}left_A 和 \text{left\_B}left_B 放入一個集合，並將 \text{right\_A}right_A 和 \text{right\_B}right_B 放入另外一個集合。 再把這兩個新的集合分別命名爲 \text{left\_part}left_part 和 \text{right\_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]
若是咱們能夠確認：

\text{len}(\text{left\_part}) = \text{len}(\text{right\_part})len(left_part)=len(right_part)
\max(\text{left\_part}) \leq \min(\text{right\_part})max(left_part)≤min(right_part)
那麼，咱們已經將 \{\text{A}, \text{B}\}{A,B} 中的全部元素劃分爲相同長度的兩個部分，且其中一部分中的元素老是大於另外一部分中的元素。那麼：

\text{median} = \frac{\text{max}(\text{left}\_\text{part}) + \text{min}(\text{right}\_\text{part})}{2} median= 
2
max(left_part)+min(right_part)
​    
 

要確保這兩個條件，咱們只須要保證：

i + j = m - i + n - ji+j=m−i+n−j（或：m - i + n - j + 1m−i+n−j+1） 若是 n \geq mn≥m，只須要使 i = 0 \sim m, j = \frac{m + n + 1}{2} - i \\i=0∼m,j= 
2
m+n+1
​    
 −i
\text{B}[j-1] \leq \text{A}[i]B[j−1]≤A[i] 以及 \text{A}[i-1] \leq \text{B}[j]A[i−1]≤B[j]
ps.1 爲了簡化分析，我假設 \text{A}[i-1], \text{B}[j-1], \text{A}[i], \text{B}[j]A[i−1],B[j−1],A[i],B[j] 老是存在，哪怕出現 i=0i=0，i=mi=m，j=0j=0，或是 j=nj=n 這樣的臨界條件。 我將在最後討論如何處理這些臨界值。

ps.2 爲何 n \geq mn≥m？因爲0 \leq i \leq m0≤i≤m 且 j = \frac{m + n + 1}{2} - ij= 
2
m+n+1
​    
 −i，我必須確保 jj 不是負數。若是 n < mn<m，那麼 jj 將多是負數，而這會形成錯誤的答案。

因此，咱們須要作的是：

在 [0，m][0，m] 中搜索並找到目標對象 ii，以使：

\qquad \text{B}[j-1] \leq \text{A}[i] B[j−1]≤A[i] 且 \ \text{A}[i-1] \leq \text{B}[j],  A[i−1]≤B[j], 其中 j = \frac{m + n + 1}{2} - ij= 
2
m+n+1
​    
 −i
接着，咱們能夠按照如下步驟來進行二叉樹搜索：

設 \text{imin} = 0imin=0，\text{imax} = mimax=m, 而後開始在 [\text{imin}, \text{imax}][imin,imax] 中進行搜索。

令 i = \frac{\text{imin} + \text{imax}}{2}i= 
2
imin+imax
​    
 ， j = \frac{m + n + 1}{2} - ij= 
2
m+n+1
​    
 −i

如今咱們有 \text{len}(\text{left}\_\text{part})=\text{len}(\text{right}\_\text{part})len(left_part)=len(right_part)。 並且咱們只會遇到三種狀況：

\text{B}[j-1] \leq \text{A}[i]B[j−1]≤A[i] 且 \text{A}[i-1] \leq \text{B}[j]A[i−1]≤B[j]：
這意味着咱們找到了目標對象 ii，因此能夠中止搜索。

\text{B}[j-1] > \text{A}[i]B[j−1]>A[i]：
這意味着 \text{A}[i]A[i] 過小，咱們必須調整 ii 以使 \text{B}[j-1] \leq \text{A}[i]B[j−1]≤A[i]。
咱們能夠增大 ii 嗎？
      是的，由於當 ii 被增大的時候，jj 就會被減少。
      所以 \text{B}[j-1]B[j−1] 會減少，而 \text{A}[i]A[i] 會增大，那麼 \text{B}[j-1] \leq \text{A}[i]B[j−1]≤A[i] 就可能被知足。
咱們能夠減少 ii 嗎？
      不行，由於當 ii 被減少的時候，jj 就會被增大。
      所以 \text{B}[j-1]B[j−1] 會增大，而 \text{A}[i]A[i] 會減少，那麼 \text{B}[j-1] \leq \text{A}[i]B[j−1]≤A[i] 就可能不知足。
因此咱們必須增大 ii。也就是說，咱們必須將搜索範圍調整爲 [i+1, \text{imax}][i+1,imax]。 所以，設 \text{imin} = i+1imin=i+1，並轉到步驟 2。

\text{A}[i-1] > \text{B}[j]A[i−1]>B[j]： 這意味着 \text{A}[i-1]A[i−1] 太大，咱們必須減少 ii 以使 \text{A}[i-1]\leq \text{B}[j]A[i−1]≤B[j]。 也就是說，咱們必須將搜索範圍調整爲 [\text{imin}, i-1][imin,i−1]。
所以，設 \text{imax} = i-1imax=i−1，並轉到步驟 2。

當找到目標對象 ii 時，中位數爲：

\max(\text{A}[i-1], \text{B}[j-1]), max(A[i−1],B[j−1]), 當 m + nm+n 爲奇數時
\frac{\max(\text{A}[i-1], \text{B}[j-1]) + \min(\text{A}[i], \text{B}[j])}{2}, 
2
max(A[i−1],B[j−1])+min(A[i],B[j])
​    
 , 當 m + nm+n 爲偶數時
如今，讓咱們來考慮這些臨界值 i=0,i=m,j=0,j=ni=0,i=m,j=0,j=n，此時 \text{A}[i-1],\text{B}[j-1],\text{A}[i],\text{B}[j]A[i−1],B[j−1],A[i],B[j] 可能不存在。 其實這種狀況比你想象的要容易得多。

咱們須要作的是確保 \text{max}(\text{left}\_\text{part}) \leq \text{min}(\text{right}\_\text{part})max(left_part)≤min(right_part)。 所以，若是 ii 和 jj 不是臨界值（這意味着 \text{A}[i-1], \text{B}[j-1],\text{A}[i],\text{B}[j]A[i−1],B[j−1],A[i],B[j] 所有存在）, 那麼咱們必須同時檢查 \text{B}[j-1] \leq \text{A}[i]B[j−1]≤A[i] 以及 \text{A}[i-1] \leq \text{B}[j]A[i−1]≤B[j] 是否成立。 可是若是 \text{A}[i-1],\text{B}[j-1],\text{A}[i],\text{B}[j]A[i−1],B[j−1],A[i],B[j] 中部分不存在，那麼咱們只須要檢查這兩個條件中的一個（或不須要檢查）。 舉個例子，若是 i = 0i=0，那麼 \text{A}[i-1]A[i−1] 不存在，咱們就不須要檢查 \text{A}[i-1] \leq \text{B}[j]A[i−1]≤B[j] 是否成立。 因此，咱們須要作的是：

在 [0，m][0，m] 中搜索並找到目標對象 ii，以使：

(j = 0(j=0 or i = mi=m or \text{B}[j-1] \leq \text{A}[i])B[j−1]≤A[i]) 或是 (i = 0(i=0 or j = nj=n or \text{A}[i-1] \leq \text{B}[j]),A[i−1]≤B[j]), 其中 j = \frac{m + n + 1}{2} - ij= 
2
m+n+1
​    
 −i
在循環搜索中，咱們只會遇到三種狀況：

(j = 0(j=0 or i = mi=m or \text{B}[j-1] \leq \text{A}[i])B[j−1]≤A[i]) 或是
(i = 0(i=0 or j = nj=n or \text{A}[i-1] \leq \text{B}[j])A[i−1]≤B[j])
這意味着 ii 是完美的，咱們能夠中止搜索。
j > 0j>0 and i < mi<m and \text{B}[j - 1] > \text{A}[i]B[j−1]>A[i]
這意味着 ii 過小，咱們必須增大它。
i > 0i>0 and j < nj<n and \text{A}[i - 1] > \text{B}[j]A[i−1]>B[j]
這意味着 ii 太大，咱們必須減少它。
感謝 @Quentin.chen 指出： i < m \implies j > 0i<m⟹j>0 以及 i > 0 \implies j < ni>0⟹j<n 始終成立，這是由於：

m \leq n, i < m \implies j = \frac{m+n+1}{2} - i > \frac{m+n+1}{2} - m \geq \frac{2m+1}{2} - m \geq 0m≤n,i<m⟹j= 
2
m+n+1
​    
 −i> 
2
m+n+1
​    
 −m≥ 
2
2m+1
​    
 −m≥0

m \leq n, i > 0 \implies j = \frac{m+n+1}{2} - i < \frac{m+n+1}{2} \leq \frac{2n+1}{2} \leq nm≤n,i>0⟹j= 
2
m+n+1
​    
 −i< 
2
m+n+1
​    
 ≤ 
2
2n+1
​    
 ≤n
因此，在狀況 2 和 3中，咱們不須要檢查 j > 0j>0 或是 j < nj<n 是否成立。

 

3. 代碼實現

class Solution:
    def findMedianSortedArrays(self, list1: List[int], list2: List[int]) -> float:
        m, n = len(list1), len(list2)
        #判斷m, n的大小，保證m<n
        if m > n :
            m, n, list1, list2 = n, m, list2, list1
        if n == 0 :
            return ValueError

        #肯定搜索邊界，及最大值，最小值，以及中位值索引
        i_min, i_max, half_len, flag = 0, m, (m+n+1)//2, (m+n)%2

        while i_min <= i_max :
            i = (i_min+i_max)//2
            j = half_len - i
            if i < m and list1[i] < list2[j-1] :
                i_min = i + 1            
            elif i > 0 and list1[i-1] > list2[j] :
                i_max = i - 1
            else :
                if i == 0 :
                    max_left = list2[j-1]
                elif j == 0 :
                    max_left = list1[i-1]
                else :
                    max_left = max(list1[i-1],list2[j-1])

                if flag == 1:
                    return max_left

                if i == m :
                    min_right = list2[j]
                elif j == n :
                    min_right = list1[i]
                else :
                    min_right = min(list1[i], list2[j])

                return (max_left + min_right)/2