【困难】力扣算法题解析LeetCode4：寻找两个正序数组的中位数

关注文末推广名片，即可免费获得本题测试源码！

题目来源：LeetCode4：寻找两个正序数组的中位数

问题抽象： 给定两个非降序排列的整数数组 nums1 和 nums2，其长度分别为 m 和 n（可能为空）。要求找到这两个数组合并后的中位数，并满足：

1. 有序合并：需基于数组已排序的特性高效计算，禁止显式合并整个数组（避免 O(m+n) 空间）。
2. 中位数定义：
   • 若合并数组长度为奇数，中位数为正中间的元素；
   • 若长度为偶数，中位数为中间两个元素的平均值（可能为小数）。
3. 复杂度约束：需设计时间复杂度 O(log(min(m,n))) 的算法（通常使用二分搜索）。
4. 边界处理：需兼容任一数组为空、所有元素为负值、或合并后数组长度为 1 的场景。

输入：两个升序整数数组 nums1、nums2
输出：合并数组中位数（浮点数或整数）

---

解题思路

二分查找（分治算法）
核心思想：将问题转化为寻找两个有序数组中第 k 小的数（k 为中间位置），通过每次排除 k/2 个元素实现对数级时间复杂度。

步骤：

1. 计算总长度 len = m + n
2. 根据总长度奇偶性确定中位数位置：
   • 奇数：第 (len+1)/2 小的数
   • 偶数：第 len/2 小和第 len/2+1 小的数的平均值
3. 实现 findKth 函数寻找第 k 小的数：
   • 始终保持 nums1 为较短的数组（优化效率）
   • 边界处理：当某个数组起始位置超出长度时，直接返回另一个数组的第 k 个元素
   • 当 k=1 时，返回两个数组起始元素的最小值
   • 计算两个数组的检查位置（避免越界）：
     pos1 = min(start1 + k/2 - 1, m-1)
pos2 = min(start2 + k/2 - 1, n-1)
   • 比较两个位置的值：
     • 若 nums1[pos1] ≤ nums2[pos2]，排除 nums1 前 pos1-start1+1 个元素
     • 否则排除 nums2 前 pos2-start2+1 个元素
4. 递归/迭代更新起始位置和 k 值，直到找到第 k 小的数

---

代码实现（Java版）🔥点击下载源码

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        int total = m + n;
        
        if (total % 2 == 1) {
            return findKth(nums1, nums2, (total + 1) / 2);
        } else {
            int left = findKth(nums1, nums2, total / 2);
            int right = findKth(nums1, nums2, total / 2 + 1);
            return (left + right) / 2.0;
        }
    }
    
    private int findKth(int[] nums1, int[] nums2, int k) {
        // 确保 nums1 是较短的数组（优化关键）
        if (nums1.length > nums2.length) {
            return findKth(nums2, nums1, k);
        }
        
        int m = nums1.length, n = nums2.length;
        int i = 0, j = 0;
        
        while (true) {
            // 边界情况处理
            if (i == m) return nums2[j + k - 1];
            if (j == n) return nums1[i + k - 1];
            if (k == 1) return Math.min(nums1[i], nums2[j]);
            
            // 计算检查位置（避免数组越界）
            int mid1 = Math.min(i + k / 2 - 1, m - 1);
            int mid2 = Math.min(j + k / 2 - 1, n - 1);
            
            // 比较并排除较小元素所在数组的前半部分
            if (nums1[mid1] <= nums2[mid2]) {
                k -= (mid1 - i + 1);  // 更新剩余查找长度
                i = mid1 + 1;         // 更新起始位置
            } else {
                k -= (mid2 - j + 1);
                j = mid2 + 1;
            }
        }
    }
}

---

代码说明

关键优化

• 交换数组顺序：始终保持 nums1 为较短的数组，将时间复杂度优化至 O(log(min(m,n)))
• 边界处理：
  • 当 nums1 被完全排除时，直接返回 nums2 中剩余部分的第 k 个元素
  • 当 nums2 被完全排除时，直接返回 nums1 中剩余部分的第 k 个元素
  • 当 k=1 时直接比较两个数组当前起始元素

位置计算

• 安全位置计算：Math.min(i + k/2 - 1, m-1) 防止数组越界
• 动态排除：
  • 排除元素数量 = (mid - start) + 1
  • 更新 k 值：k -= 排除数量
  • 更新起始位置：start = mid + 1

中位数计算

• 奇数情况：返回第 (total+1)/2 小的数
• 偶数情况：分别计算第 total/2 小和第 total/2+1 小的数，取平均值

---

边界情况测试

1. 一个数组为空：

   nums1 = [1,3], nums2 = [] → 中位数 = 2.0
   

2. 数组元素完全相同：

   nums1 = [1,1], nums2 = [1,1] → 中位数 = 1.0
   

3. 交叉数组：

   nums1 = [1,3,5], nums2 = [2,4,6] → 中位数 = 3.5
   

4. 极端长度差异：

   nums1 = [1], nums2 = [2,3,4,5,6] → 中位数 = 3.5
   

---

提交详情（执行用时、内存消耗）