阿里面試題：如何尋找「兩個數組」的中位數？

題目地址(4. 尋找兩個正序數組的中位數)

https://leetcode-cn.com/probl...

題目描述

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

前置知識

• 中位數
• 分治法
• 二分查找

公司

• 阿里
• 百度
• 騰訊

暴力法

思路

首先了解一下 Median 的概念，一個數組中 median 就是把數組分紅左右等分的中位數。

以下圖：

知道了概念，咱們先來看下如何使用暴力法來解決。

試了一下，暴力解法也是能夠被 Leetcode Accept 的。

暴力解主要是要 merge 兩個排序的數組（A，B）成一個排序的數組。

用兩個pointer（i，j），i 從數組A起始位置開始，即i=0開始，j 從數組B起始位置， 即j=0開始.
一一比較 A[i] 和 B[j],

1. 若是A[i] <= B[j], 則把A[i] 放入新的數組中，i 日後移一位，即 i+1.
2. 若是A[i] > B[j], 則把B[j] 放入新的數組中，j 日後移一位，即 j+1.
3. 重複步驟#1 和 #2，直到i移到A最後，或者j移到B最後。
4. 若是j移動到B數組最後，那麼直接把剩下的全部A依次放入新的數組中.
5. 若是i移動到A數組最後，那麼直接把剩下的全部B依次放入新的數組中.

整個過程相似歸併排序的合併過程

Merge 的過程以下圖。

時間複雜度和空間複雜度都是O(m+n), 不符合題中給出O(log(m+n))時間複雜度的要求。

代碼

代碼支持： Java，JS：

Java Code：

class MedianTwoSortedArrayBruteForce {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
      int[] newArr = mergeTwoSortedArray(nums1, nums2);
      int n = newArr.length;
      if (n % 2 == 0) {
        // even
        return (double) (newArr[n / 2] + newArr[n / 2 - 1]) / 2;
      } else {
        // odd
        return (double) newArr[n / 2];
      }
    }
    private int[] mergeTwoSortedArray(int[] nums1, int[] nums2) {
      int m = nums1.length;
      int n = nums2.length;
      int[] res = new int[m + n];
      int i = 0;
      int j = 0;
      int idx = 0;
      while (i < m && j < n) {
        if (nums1[i] <= nums2[j]) {
          res[idx++] = nums1[i++];
        } else {
          res[idx++] = nums2[j++];
        }
      }
      while (i < m) {
        res[idx++] = nums1[i++];
      }
      while (j < n) {
        res[idx++] = nums2[j++];
      }
      return res;
    }
}

JS Code:

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number}
 */
var findMedianSortedArrays = function (nums1, nums2) {
  // 歸併排序
  const merged = [];
  let i = 0;
  let j = 0;
  while (i < nums1.length && j < nums2.length) {
    if (nums1[i] < nums2[j]) {
      merged.push(nums1[i++]);
    } else {
      merged.push(nums2[j++]);
    }
  }
  while (i < nums1.length) {
    merged.push(nums1[i++]);
  }
  while (j < nums2.length) {
    merged.push(nums2[j++]);
  }

  const { length } = merged;
  return length % 2 === 1
    ? merged[Math.floor(length / 2)]
    : (merged[length / 2] + merged[length / 2 - 1]) / 2;
};

複雜度分析

• 時間複雜度：$O(max(m, n))$
• 空間複雜度：$O(m + n)$

二分查找

思路

若是咱們把上一種方法的最終結果拿出來單獨看的話，不難發現最終結果就是 nums1 和 nums 兩個數組交錯造成的新數組，也就是說 nums1 和 nums2 的相對位置並不會發生變化，這是本題的關鍵信息之一。

爲了方便描述，不妨假設最終分割後，數組 nums1 左側部分是 A，數組 nums2 左側部分是 B。因爲題中給出的數組都是排好序的，在排好序的數組中查找很容易想到能夠用二分查找（Binary Search)·, 這裏對數組長度小的作二分以減小時間複雜度。對較小的數組作二分可行的緣由在於若是一個數組的索引 i 肯定了，那麼另外一個數組的索引位置 j 也是肯定的，由於 (i+1) + (j+1) 等於 (m + n + 1) / 2，其中 m 是數組 A 的長度， n 是數組 B 的長度。具體來講，咱們能夠保證數組 A 和 數組 B 作 partition 以後，len(Aleft)+len(Bleft)=(m+n+1)/2

接下來須要特別注意四個指針：leftp1, rightp1, leftp2, rightp2，分別表示 A 數組分割點，A 數組分割點右側數，B 數組分割點，B 數組分割點右側數。不過這裏有兩個臨界點須要特殊處理：

• 若是分割點左側沒有數，即分割點索引是 0，那麼其左側應該設置爲無限小。
• 若是分割點右側沒有數，即分割點索引是數組長度-1，那麼其左側應該設置爲無限大。

若是咱們二分以後知足：leftp1 < rightp2 and leftp2 < rightp1,那麼說明分割是正確的，直接返回max(leftp1, leftp2)+min(rightp1, rightp2) 便可。不然，說明分割無效，咱們須要調整分割點。

如何調整呢？實際上只須要判斷 leftp1 > rightp2 的大小關係便可。若是 leftp1 > rightp2，那麼說明 leftp1 太大了，咱們能夠經過縮小上界來下降 leftp1，不然咱們須要擴大下界。

核心代碼：

if leftp1 > rightp2:
    hi = mid1 - 1
else:
    lo = mid1 + 1

上面的調整上下界的代碼是創建在對數組 nums1 進行二分的基礎上的，若是咱們對數組 nums2 進行二分，那麼相應地須要改成：

if leftp2 > rightp1:
    hi = mid2 - 1
else:
    lo = mid2 + 1

下面咱們經過一個具體的例子來講明。

好比對數組 A 的作 partition 的位置是區間[0,m]

如圖：

下圖給出幾種不一樣狀況的例子（注意但左邊或者右邊沒有元素的時候，左邊用INF_MIN，右邊用INF_MAX表示左右的元素：

下圖給出具體作的 partition 解題的例子步驟，

這個算法關鍵在於：

1. 要 partition 兩個排好序的數組成左右兩等份，partition 須要知足len(Aleft)+len(Bleft)=(m+n+1)/2 - m是數組A的長度， n是數組B的長度，
2. 且 partition 後 A 左邊最大(maxLeftA), A 右邊最小（minRightA), B 左邊最大（maxLeftB), B 右邊最小（minRightB) 知足
   (maxLeftA <= minRightB && maxLeftB <= minRightA)

關鍵點分析

• 有序數組容易想到二分查找
• 對小的數組進行二分可下降時間複雜度
• 根據 leftp1,rightp2,leftp2 和 rightp1 的大小關係肯定結束點和收縮方向

代碼

代碼支持：JS，CPP， Python3，

JS Code:

/**
 * 二分解法
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number}
 */
var findMedianSortedArrays = function (nums1, nums2) {
  // make sure to do binary search for shorten array
  if (nums1.length > nums2.length) {
    [nums1, nums2] = [nums2, nums1];
  }
  const m = nums1.length;
  const n = nums2.length;
  let low = 0;
  let high = m;
  while (low <= high) {
    const i = low + Math.floor((high - low) / 2);
    const j = Math.floor((m + n + 1) / 2) - i;

    const maxLeftA = i === 0 ? -Infinity : nums1[i - 1];
    const minRightA = i === m ? Infinity : nums1[i];
    const maxLeftB = j === 0 ? -Infinity : nums2[j - 1];
    const minRightB = j === n ? Infinity : nums2[j];

    if (maxLeftA <= minRightB && minRightA >= maxLeftB) {
      return (m + n) % 2 === 1
        ? Math.max(maxLeftA, maxLeftB)
        : (Math.max(maxLeftA, maxLeftB) + Math.min(minRightA, minRightB)) / 2;
    } else if (maxLeftA > minRightB) {
      high = i - 1;
    } else {
      low = low + 1;
    }
  }
};

Java Code:

class MedianSortedTwoArrayBinarySearch {
  public static double findMedianSortedArraysBinarySearch(int[] nums1, int[] nums2) {
     // do binary search for shorter length array, make sure time complexity log(min(m,n)).
     if (nums1.length > nums2.length) {
        return findMedianSortedArraysBinarySearch(nums2, nums1);
      }
      int m = nums1.length;
      int n = nums2.length;
      int lo = 0;
      int hi = m;
      while (lo <= hi) {
        // partition A position i
        int i = lo + (hi - lo) / 2;
        // partition B position j
        int j = (m + n + 1) / 2 - i;

        int maxLeftA = i == 0 ? Integer.MIN_VALUE : nums1[i - 1];
        int minRightA = i == m ? Integer.MAX_VALUE : nums1[i];

        int maxLeftB = j == 0 ? Integer.MIN_VALUE : nums2[j - 1];
        int minRightB = j == n ? Integer.MAX_VALUE : nums2[j];

        if (maxLeftA <= minRightB && maxLeftB <= minRightA) {
          // total length is even
          if ((m + n) % 2 == 0) {
            return (double) (Math.max(maxLeftA, maxLeftB) + Math.min(minRightA, minRightB)) / 2;
          } else {
            // total length is odd
            return (double) Math.max(maxLeftA, maxLeftB);
          }
        } else if (maxLeftA > minRightB) {
          // binary search left half
          hi = i - 1;
        } else {
          // binary search right half
          lo = i + 1;
        }
      }
      return 0.0;
    }
}

CPP Code:

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        if (nums1.size() > nums2.size()) swap(nums1, nums2);
        int M = nums1.size(), N = nums2.size(), L = 0, R = M, K = (M + N + 1) / 2;
        while (true) {
            int i = (L + R) / 2, j = K - i;
            if (i < M && nums2[j - 1] > nums1[i]) L = i + 1;
            else if (i > L && nums1[i - 1] > nums2[j]) R = i - 1;
            else {
                int maxLeft = max(i ? nums1[i - 1] : INT_MIN, j ? nums2[j - 1] : INT_MIN);
                if ((M + N) % 2) return maxLeft;
                int minRight = min(i == M ? INT_MAX : nums1[i], j == N ? INT_MAX : nums2[j]);
                return (maxLeft + minRight) / 2.0;
            }
        }
    }
};

Python3 Code:

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        N = len(nums1)
        M = len(nums2)
        if N > M:
            return self.findMedianSortedArrays(nums2, nums1)

        lo = 0
        hi = N
        combined = N + M

        while lo <= hi:
            mid1 = lo + hi >> 1
            mid2 = ((combined + 1) >> 1) - mid1

            leftp1 = -float("inf") if mid1 == 0 else nums1[mid1 - 1]
            rightp1 = float("inf") if mid1 == N else nums1[mid1]

            leftp2 = -float("inf") if mid2 == 0 else nums2[mid2 - 1]
            rightp2 = float("inf") if mid2 == M else nums2[mid2]

            # Check if the partition is valid for the case of
            if leftp1 <= rightp2 and leftp2 <= rightp1:
                if combined % 2 == 0:
                    return (max(leftp1, leftp2)+min(rightp1, rightp2)) / 2.0

                return max(leftp1, leftp2)
            else:
                if leftp1 > rightp2:
                    hi = mid1 - 1
                else:
                    lo = mid1 + 1
        return -1

複雜度分析

• 時間複雜度：$O(log(min(m, n)))$
• 空間複雜度：$O(log(min(m, n)))$

你們對此有何見解，歡迎給我留言，我有時間都會一一查看回答。更多算法套路能夠訪問個人 LeetCode 題解倉庫：https://github.com/azl3979858... 。 目前已經 40K star 啦。你們也能夠關注個人公衆號《力扣加加》帶你啃下算法這塊硬骨頭。