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

在这里插入图片描述

💯 完全正确！！你这段话可以直接当作这道题的**“思路总览”模板答案**了，结构清晰、逻辑严谨、几乎没有遗漏任何关键点👏

不过我可以帮你稍微精炼一下语言，使它在保留你原本意思的基础上更具表达力和条理性 👇

✅ 【LeetCode 第 4 题：寻找两个正序数组的中位数】解题流程总结

1. 预处理 Trick：始终在较短的数组上二分

设 nums1 是较短的那个数组（如果不是，就交换）
这样可以将时间复杂度控制在 O(log(min(m, n)))

2. 初始化二分边界

设置 left = 0, right = m（m 是 nums1 的长度）
因为划分点 i 可能从 0 到 m，共 m + 1 个可能位置

3. 开始二分循环，动态更新划分点 `i`、`j`

i 是 nums1 的划分位置
j = (m + n + 1) / 2 - i，使得左边总元素个数等于右边（或多1）

4. 从 `i` 和 `j` 推出划分点两侧的关键值

maxLeft1, minRight1：是 nums1 左右两边的最大/最小值
maxLeft2, minRight2：是 nums2 左右两边的最大/最小值
利用 Integer.MIN_VALUE 和 Integer.MAX_VALUE 做边界处理（哨兵）

5. 判断是否满足中位数的合法划分条件

if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1)

✅ 满足：说明找到了正确划分点
- 如果总长度是奇数：中位数是左边最大值 max(maxLeft1, maxLeft2)
- 如果是偶数：中位数是左最大与右最小的平均值
  avg = (max(maxLeft1, maxLeft2) + min(minRight1, minRight2)) / 2.0

6. 如果不满足，调整二分边界

maxLeft1 > minRight2 → 说明 i 太大了，往左缩：right = i - 1
maxLeft2 > minRight1 → 说明 i 太小了，往右扩：left = i + 1

7. 循环结束前要有兜底的 throw

理论上不会走到，但为了编译通过 + 程序健壮性加一行：

throw new IllegalArgumentException("Invalid input");

🎉 总结一句话：

你刚才那段话说得非常对，概括起来就是：

先二分短数组，逐步调整划分点，计算分界值，判断合法性，满足就返回中位数，否则继续二分直到找到！

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if(nums1.length > nums2.length) { //保证复杂度是O(log(min(m,n)))
            return findMedianSortedArrays(nums2, nums1);
        }
        int m = nums1.length;
        int n = nums2.length;
        int left = 0, right = m; //只需要对 nums1 进行二分，设置一组 left 和 right 指针，就足够

        while(left <= right) {
            //划分后，“两个数组左边的元素数量的总和”不能小于“右边的总数量”
            //但某一个数组内部的左边元素数量可以小于右边的数量
            //i + j = (m + n + 1) / 2

            int i = (left + right) / 2; //i的含义是nums1划分之后左边有i个元素

            int j = (m + n + 1) / 2 - i;

            int maxLeft1 = (i == 0) ? Integer.MIN_VALUE : nums1[i - 1]; // i == 0 说明这个划分s1左边没有元素,也就是说左边不可能有更小的元素了
            int minRight1 = (i == m) ? Integer.MAX_VALUE : nums1[i]; // i == m 说明这个划分s1右边没有元素

            int maxLeft2 = (j == 0) ? Integer.MIN_VALUE : nums2[j - 1];
            int minRight2 = (j == n) ? Integer.MAX_VALUE : nums2[j];

            if(maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {
                //如果是偶数
                if((m + n) % 2 == 0) {
                    return (Math.max(maxLeft1, maxLeft2) + Math.min(minRight1, minRight2)) / 2.0; 
                } else{
                    return Math.max(maxLeft1, maxLeft2);
                }
            } else if(maxLeft1 > minRight2) {
                right = i - 1;
            } else {
                left = i + 1;
            }
        }
        throw new IllegalArgumentException("Input arrays are not valid.");
    }   
}

当然可以！我们来详细解释这段 Java 代码的算法思想，理解这题的关键在于：如何将两个有序数组“合理划分”，使得划分后的左右两边满足中位数定义的条件。

🧠 题目回顾

给定两个有序数组 nums1 和 nums2，总长度为 m + n，要求时间复杂度为 O(log(min(m, n)))，找到这两个数组的中位数。

🎯 解题目标

中位数的定义是：

当元素总数为奇数时，中位数是第 (m+n)/2 + 1 个元素；
当总数为偶数时，中位数是第 (m+n)/2 和 (m+n)/2 + 1 个元素的平均值。

我们不能直接合并数组（那是 O(m+n) 的做法），所以需要用 二分法 进行优化。

🧩 算法思想：二分划分法

我们要找到一个划分，使得：

nums1: [ A1_left | A1_right ]
nums2: [ A2_left | A2_right ]

满足：

max(A1_left, A2_left) <= min(A1_right, A2_right)

这样，左边都是较小的元素，右边是较大的元素，左边和右边刚好划分了所有元素的一半。

然后根据长度是奇数还是偶数返回：

若总长度为奇数，返回 max(A1_left, A2_left)
若总长度为偶数，返回 (max(A1_left, A2_left) + min(A1_right, A2_right)) / 2

🔍 代码逐行解释

if (nums1.length > nums2.length) {
    return findMedianSortedArrays(nums2, nums1);
}

始终在较短的数组上二分，保证时间复杂度是 O(log(min(m,n)))。

int m = nums1.length;
int n = nums2.length;
int left = 0, right = m;

我们在 nums1 上做二分，i 表示在 nums1 中划分的位置（0 ~ m），而对应的 j = (m+n+1)/2 - i，这样能确保两边的元素数量平衡。

while (left <= right) {
    int i = (left + right) / 2;
    int j = (m + n + 1) / 2 - i;

i 和 j 是当前划分点。

int maxLeft1 = (i == 0) ? Integer.MIN_VALUE : nums1[i - 1];
int minRight1 = (i == m) ? Integer.MAX_VALUE : nums1[i];

int maxLeft2 = (j == 0) ? Integer.MIN_VALUE : nums2[j - 1];
int minRight2 = (j == n) ? Integer.MAX_VALUE : nums2[j];

这些是划分之后左右两边的最大最小值，注意边界条件（比如某边为空时，用极小或极大值来填补）。

if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {
    // 划分正确，计算中位数
    if ((m + n) % 2 == 0) {
        return (Math.max(maxLeft1, maxLeft2) + Math.min(minRight1, minRight2)) / 2.0;
    } else {
        return Math.max(maxLeft1, maxLeft2);
    }
}

如果左右满足条件，就可以得出结果：

总长偶数：取中间两个数平均值；
总长奇数：取左边最大值。

else if (maxLeft1 > minRight2) {
    right = i - 1; // i 太大了，向左缩
} else {
    left = i + 1; // i 太小了，向右扩
}

这部分是标准的二分查找逻辑。逐步逼近正确的划分点。

✅ 时间复杂度分析

二分查找在长度为 min(m, n) 的数组上执行；
每次减半搜索空间；
所以时间复杂度是 O(log(min(m, n)))。

📌 举个例子说明

比如 nums1 = [1, 3]，nums2 = [2]

总长度为 3（奇数），目标是找到第 2 个元素。

尝试划分：

i = 1 -> nums1 = [1 | 3]
j = 1 -> nums2 = [2 | ]

左半部分：1, 2
右半部分：3

maxLeft = max(1, 2) = 2
minRight = min(3, ∞) = 3

满足条件，且为奇数，返回 maxLeft = 2

非常好！你现在已经深入到了这道题的二分核心判断逻辑部分，这段：

else if (maxLeft1 > minRight2) {
    right = i - 1;
} else {
    left = i + 1;
}

是整个算法里最关键的“二分调整方向”部分。理解它，就完全掌握了为什么这个算法能用二分来做中位数查找。

🎯 首先，我们在干嘛？

我们在对 nums1 做二分查找，寻找一个划分点 i，使得配对出来的 j = (m + n + 1) / 2 - i 也刚好构成一个“合法划分”。

什么叫合法划分？

maxLeft1 <= minRight2 && maxLeft2 <= minRight1

也就是说：左半边最大的 ≤ 右半边最小的。

💡 那么：如果不满足这个条件，说明了什么？

我们来看看这句：

else if (maxLeft1 > minRight2) {
    right = i - 1; // i 太大了，向左缩
}

这句的含义是：

maxLeft1 太大了
而 minRight2 太小了
说明 nums1 的左边元素太多了，i 划分得太靠右
所以你要把 i 往左调，减少 nums1 左边的元素个数

于是我们更新二分边界为：

right = i - 1;

❗ 这和传统二分判断一样！

你可以把它看成是在找一个“满足条件的 i”，
当你发现当前值“太大”，你就缩小右边界，向左逼近：

if (currentValue > target) {
    right = mid - 1;
}

逻辑是一样的。

✅ 相对地，另一分支是：

else {
    left = i + 1; // i 太小了，向右扩
}

含义是：

maxLeft2 > minRight1
nums1 这边的左半边太少了（i 太小）
要划分得更靠右，才能增加 nums1 的左半边

于是我们向右扩大 i：

left = i + 1;

🔁 总结这两句话的含义：

条件	说明	该怎么调
`maxLeft1 > minRight2`	`nums1` 左边太多（或太大）	`i` 要往左缩，`right = i - 1`
`maxLeft2 > minRight1`（else 情况）	`nums1` 左边太少（或太小）	`i` 要往右扩，`left = i + 1`
满足 `maxLeft1 <= minRight2 && maxLeft2 <= minRight1`	找到了合法划分	直接 return 中位数