「前端刷题」4. 寻找两个正序数组的中位数

明无生
295 阅读3分钟

这是我参与8月更文挑战的第4天，活动详情查看：8月更文挑战

题目

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

 

示例 1：

输入： nums1 = [1,3], nums2 = [2] 输出： 2.00000 解释： 合并数组 = [1,2,3] ，中位数 2

示例 2：

输入： nums1 = [1,2], nums2 = [3,4] 输出： 2.50000 解释： 合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

示例 3：

输入： nums1 = [0,0], nums2 = [0,0] 输出： 0.00000

示例 4：

输入： nums1 = [], nums2 = [1] 输出： 1.00000

示例 5：

输入： nums1 = [2], nums2 = [] 输出： 2.00000

 

提示：

  • nums1.length == m
  • nums2.length == n
  • 0 <= m <= 1000
  • 0 <= n <= 1000
  • 1 <= m + n <= 2000
  • -106 <= nums1[i], nums2[i] <= 106

 

进阶： 你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？

解题思路

首先了解一下Median的概念，一个数组中median就是把数组分成左右等分的中位数。

如下图：
image.png

这道题，很容易想到暴力解法，时间复杂度和空间复杂度都是O(m+n), 不符合题中给出O(log(m+n))时间复杂度的要求。
我们可以从简单的解法入手，试了一下，暴力解法也是可以被Leetcode Accept的. 分析中会给出两种解法，暴力求解和二分解法。

思路1 暴力（Brute Force）

暴力解主要是要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的过程如下图。
image.png

时间复杂度： O(m+n) \- m is length of A, n is length of B

空间复杂度： O(m+n)

思路2 二分查找 （Binary Search）

由于题中给出的数组都是排好序的，在排好序的数组中查找很容易想到可以用二分查找（Binary Search), 这里对数组长度小的做二分，
保证数组A 和 数组B 做partition 之后

len(Aleft)+len(Bleft)=(m+n+1)/2 \- m是数组A的长度， n是数组B的长度

对数组A的做partition的位置是区间[0,m]

如图：
image.png

下图给出几种不同情况的例子（注意但左边或者右边没有元素的时候，左边用INF_MIN，右边用INF_MAX表示左右的元素：
image.png

下图给出具体做的partition 解题的例子步骤，
image.png

时间复杂度： O(log(min(m, n)) \- m is length of A, n is length of B

空间复杂度： O(1) - 这里没有用额外的空间

思路3

  1. 对两个数组进行合并然后调用数组的sort方法进行升序排序
  2. 将新数组的长度除以2，并向下取整，赋值给变量mid
  3. 如果新数组的长度是奇数，则返回arr[mid]，如果是偶数，则返回(arr[mid] + arr[mid - 1]) / 2

关键点分析

  1. 暴力求解，在线性时间内merge两个排好序的数组成一个数组。
  2. 二分查找，关键点在于

  • 要partition两个排好序的数组成左右两等份，partition需要满足len(Aleft)+len(Bleft)=(m+n+1)/2 \- m是数组A的长度， n是数组B的长度

  • 并且partition后 A左边最大(maxLeftA), A右边最小（minRightA), B左边最大（maxLeftB), B右边最小（minRightB) 满足
    (maxLeftA <= minRightB && maxLeftB <= minRightA)

有了这两个条件，那么median就在这四个数中，根据奇数或者是偶数，

奇数： median = max(maxLeftA, maxLeftB) 偶数： median = (max(maxLeftA, maxLeftB) + min(minRightA, minRightB)) / 2

代码

思路1

/**
 * @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(max(m, n))O(max(m,n))
  • 空间复杂度：O(m+n)O(m + n)O(m+n)

思路2

/**
 * 二分解法
 * @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
    }
  }
};

复杂度分析

  • 时间复杂度：O(log(min(m,n)))O(log(min(m, n)))O(log(min(m,n)))
  • 空间复杂度：O(log(min(m,n)))O(log(min(m, n)))O(log(min(m,n)))

思路3

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number}
 */
var findMedianSortedArrays = function (nums1, nums2) {
  const arr = [...nums1, ...nums2];
  // return arr.reduce((acc, cur) => acc + cur) / arr.length;
  const mid = Math.floor(arr.sort((a, b) => a - b).length / 2);
  if (arr.length % 2 === 1) {
    return arr[mid];
  }
  return (arr[mid] + arr[mid - 1]) / 2;
};

最后

曾梦想仗剑走天涯

看一看世界的繁华

年少的心总有些轻狂

终究不过是个普通人

无怨无悔我走我路

「前端刷题」No.4

avatar
文章
阅读
粉丝