寻找两个正序数组的中位数

⛅前言

大家好，我是知识汲取者，欢迎来到我的LeetCode热题100刷题专栏！

精选 100 道力扣（LeetCode）上最热门的题目，适合初识算法与数据结构的新手和想要在短时间内高效提升的人，熟练掌握这 100 道题，你就已经具备了在代码世界通行的基本能力。在此专栏中，我们将会涵盖各种类型的算法题目，包括但不限于数组、链表、树、字典树、图、排序、搜索、动态规划等等，并会提供详细的解题思路以及Java代码实现。如果你也想刷题，不断提升自己，就请加入我们吧！QQ群号：827302436。我们共同监督打卡，一起学习，一起进步。

博客主页💖：知识汲取者的博客

LeetCode热题100专栏🚀：LeetCode热题100

Gitee地址📁：知识汲取者 (aghp) - Gitee.com

Github地址📁：Chinafrfq · GitHub

题目来源📢：LeetCode 热题 100 - 学习计划 - 力扣（LeetCode）全球极客挚爱的技术成长平台

PS：作者水平有限，如有错误或描述不当的地方，恳请及时告诉作者，作者将不胜感激

🔒题目

原题链接：4. 寻找两个正序数组的中位数 - 力扣（LeetCode）

🔑题解

• 解法一：双指针

  这一题初看难度标记，是困难，吓我一跳，但一看通过率居然接近50%，就越想越不对了，困难题居然通过率接近50%，不太现实，难道大家都这么强？结果一看题，发现是个纸老虎，直接使用双指针遍历一下就通过了。

  先来说一下我的做题思路吧O(∩_∩)O，这题我主要是借鉴归并排序的思想，因为是两个有序数组嘛，直接归并，然后求中位数，就ok了，时间复杂度也一点不用担心，刚好将两个数组遍历一遍就能得到答案了，时间复杂度刚好控制在$log(m+n)$。唯一需要注意的就是奇数与偶数时，中位数的求取是有差别的。总的来讲感觉这一题，不应该标记为难题啊，感觉比一些中等题都要简单😄

  解题主要步骤：

  • Step1：归并。将两个有序数组合并为一个有序数组，使用双指针进行合并，效率高
  • Step2：求中位数。这个没什么讲的，直接看代码就能理解

  /**
   * @author ghp
   * @title 寻找两个正序数组的中位数
   */
  class Solution {
      public double findMedianSortedArrays(int[] nums1, int[] nums2) {
          int m = nums1.length;
          int n = nums2.length;
          if (m == 0 && n == 0) {
              // 两个数组都为空时，直接返回0，防止后面出现NPE
              return 0;
          }
  
          // 合并数组
          int i = 0; // 用于遍历nums1
          int j = 0; // 用于遍历nums2
          int k = 0; // 用于遍历nums，构建新数组
          int[] nums = new int[m + n];
          while (i != m && j != n) {
              if (nums1[i] <= nums2[j]) {
                  nums[k++] = nums1[i++];
              } else {
                  nums[k++] = nums2[j++];
              }
          }
          // nums1还有元素
          while (i != m) {
              nums[k++] = nums1[i++];
          }
          // nums2还有元素
          while (j != n) {
              nums[k++] = nums2[j++];
          }
  
          // 求中位数
          int len = nums.length;
          if (len % 2 != 0) {
              // 奇数个元素时，中位数不需要求平均，直接返回
              return nums[len / 2];
          }
          return (double) (nums[len / 2] + nums[(len - 1) / 2]) / 2;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(log(m+n))$
  • 空间复杂度：$O(m+n)$

  其中 $n、m$ 为数组$nums1、nums2$中元素的个数

---

LeetCode官网提供了蛮多解法的，这里不一一列举了，感兴趣的可以自行去观看(●’◡’●)

🚪传送门

• 解法二：二分查找

  class Solution {
      public double findMedianSortedArrays(int[] nums1, int[] nums2) {
          int length1 = nums1.length, length2 = nums2.length;
          int totalLength = length1 + length2;
          if (totalLength % 2 == 1) {
              int midIndex = totalLength / 2;
              double median = getKthElement(nums1, nums2, midIndex + 1);
              return median;
          } else {
              int midIndex1 = totalLength / 2 - 1, midIndex2 = totalLength / 2;
              double median = (getKthElement(nums1, nums2, midIndex1 + 1) + getKthElement(nums1, nums2, midIndex2 + 1)) / 2.0;
              return median;
          }
      }
  
      public int getKthElement(int[] nums1, int[] nums2, int k) {
          /* 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
           * 这里的 "/" 表示整除
           * nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
           * nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
           * 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
           * 这样 pivot 本身最大也只能是第 k-1 小的元素
           * 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
           * 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
           * 由于我们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数
           */
  
          int length1 = nums1.length, length2 = nums2.length;
          int index1 = 0, index2 = 0;
          int kthElement = 0;
  
          while (true) {
              // 边界情况
              if (index1 == length1) {
                  return nums2[index2 + k - 1];
              }
              if (index2 == length2) {
                  return nums1[index1 + k - 1];
              }
              if (k == 1) {
                  return Math.min(nums1[index1], nums2[index2]);
              }
              
              // 正常情况
              int half = k / 2;
              int newIndex1 = Math.min(index1 + half, length1) - 1;
              int newIndex2 = Math.min(index2 + half, length2) - 1;
              int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];
              if (pivot1 <= pivot2) {
                  k -= (newIndex1 - index1 + 1);
                  index1 = newIndex1 + 1;
              } else {
                  k -= (newIndex2 - index2 + 1);
                  index2 = newIndex2 + 1;
              }
          }
      }
  }
  
  作者：LeetCode-Solution
  链接：https://leetcode.cn/problems/median-of-two-sorted-arrays/solution/xun-zhao-liang-ge-you-xu-shu-zu-de-zhong-wei-s-114/
  来源：力扣（LeetCode）
  著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
  

  复杂度分析：

  • 时间复杂度：$O(log(m+n))$
  • 空间复杂度：$O(m+n)$

  其中 $n、m$ 为数组$nums1、nums2$中元素的个数

• 解法三：划分数组

  这个解法可以说很牛逼，时间复杂度更小，直接是$logmin(m,n)$，简直太强了，但是理解起来有点复杂

  嘿嘿，这里就不多做解释了，感兴趣的可以去参考一下LeetCode官方提供的推到过程

  class Solution {
      public double findMedianSortedArrays(int[] nums1, int[] nums2) {
          if (nums1.length > nums2.length) {
              return findMedianSortedArrays(nums2, nums1);
          }
  
          int m = nums1.length;
          int n = nums2.length;
          int left = 0, right = m;
          // median1：前一部分的最大值
          // median2：后一部分的最小值
          int median1 = 0, median2 = 0;
  
          while (left <= right) {
              // 前一部分包含 nums1[0 .. i-1] 和 nums2[0 .. j-1]
              // 后一部分包含 nums1[i .. m-1] 和 nums2[j .. n-1]
              int i = (left + right) / 2;
              int j = (m + n + 1) / 2 - i;
  
              // nums_im1, nums_i, nums_jm1, nums_j 分别表示 nums1[i-1], nums1[i], nums2[j-1], nums2[j]
              int nums_im1 = (i == 0 ? Integer.MIN_VALUE : nums1[i - 1]);
              int nums_i = (i == m ? Integer.MAX_VALUE : nums1[i]);
              int nums_jm1 = (j == 0 ? Integer.MIN_VALUE : nums2[j - 1]);
              int nums_j = (j == n ? Integer.MAX_VALUE : nums2[j]);
  
              if (nums_im1 <= nums_j) {
                  median1 = Math.max(nums_im1, nums_jm1);
                  median2 = Math.min(nums_i, nums_j);
                  left = i + 1;
              } else {
                  right = i - 1;
              }
          }
  
          return (m + n) % 2 == 0 ? (median1 + median2) / 2.0 : median1;
      }
  }
  
  作者：LeetCode-Solution
  链接：https://leetcode.cn/problems/median-of-two-sorted-arrays/solution/xun-zhao-liang-ge-you-xu-shu-zu-de-zhong-wei-s-114/
  来源：力扣（LeetCode）
  著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
  

  复杂度分析：

  • 时间复杂度：$O(logmin(m,n))$
  • 空间复杂度：$O(m+n)$

  其中 $n、m$ 为数组$nums1、nums2$中元素的个数