Java版LeetCode热题100之寻找两个正序数组的中位数：从暴力到最优解的全面解析

本文将深入剖析 LeetCode 第4题「寻找两个正序数组的中位数」，通过多种解法、复杂度分析、面试技巧与实际应用，带你彻底掌握这道被誉为“LeetCode最难”的经典算法题。

一、原题回顾

题目描述（LeetCode 4. 寻找两个正序数组的中位数）

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

算法的时间复杂度应该为O(log (m+n))。

示例

示例 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

约束条件

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

二、原题分析

这道题的难点在于：

1. 时间复杂度要求极高：O(log(m+n))→ 暗示必须使用二分查找；
2. 不能合并数组：合并需要O(m+n)时间和空间；
3. 中位数定义依赖总长度奇偶性：
   • 奇数：第(m+n)/2 + 1小的数；
   • 偶数：第(m+n)/2和(m+n)/2 + 1小的数的平均值。

关键转化

问题可转化为：在两个有序数组中找到第 k 小的元素。

• 若m+n为奇数 → 找第k = (m+n)/2 + 1小的数；
• 若m+n为偶数 → 找第k1 = (m+n)/2和k2 = (m+n)/2 + 1小的数。

✅ 核心挑战：如何在O(log k)时间内找到第 k 小的元素？

三、答案构思

方法一：二分查找第 k 小元素（推荐）

核心思想：每次排除k/2个不可能是第 k 小的元素。

• 比较nums1[k/2-1]和nums2[k/2-1]；
• 较小者及其前面的所有元素都不可能是第 k 小（因为最多只有k-2个元素比它小）；
• 排除这些元素，更新k，递归处理。

方法二：划分数组（更优，但更难理解）

核心思想：将两个数组划分为左右两部分，使得：

• 左半部分长度 = 右半部分长度（或 +1）；
• 左半部分最大值 ≤ 右半部分最小值。

通过二分查找合适的划分点，直接计算中位数。

💡 方法一更直观，方法二时间复杂度更低（O(log min(m,n))）。

四、完整答案（Java 实现）

方法一：二分查找第 k 小元素

classSolution{publicdoublefindMedianSortedArrays(int[]nums1,int[]nums2){inttotalLength=nums1.length+nums2.length;if(totalLength%2==1){// 奇数：返回第 (totalLength/2 + 1) 小的数returngetKthElement(nums1,nums2,totalLength/2+1);}else{// 偶数：返回第 totalLength/2 和 totalLength/2+1 小的数的平均值return(getKthElement(nums1,nums2,totalLength/2)+getKthElement(nums1,nums2,totalLength/2+1))/2.0;}}/** * 找到两个有序数组中第 k 小的元素（k 从 1 开始） */privateintgetKthElement(int[]nums1,int[]nums2,intk){intlen1=nums1.length,len2=nums2.length;intindex1=0,index2=0;// 当前搜索起始位置while(true){// 边界情况1：nums1 已遍历完if(index1==len1){returnnums2[index2+k-1];}// 边界情况2：nums2 已遍历完if(index2==len2){returnnums1[index1+k-1];}// 边界情况3：k=1，返回当前最小值if(k==1){returnMath.min(nums1[index1],nums2[index2]);}// 正常情况：尝试排除 k/2 个元素inthalf=k/2;// 计算新索引，防止越界intnewIndex1=Math.min(index1+half,len1)-1;intnewIndex2=Math.min(index2+half,len2)-1;intpivot1=nums1[newIndex1],pivot2=nums2[newIndex2];if(pivot1<=pivot2){// 排除 nums1[index1 ... newIndex1]k-=(newIndex1-index1+1);index1=newIndex1+1;}else{// 排除 nums2[index2 ... newIndex2]k-=(newIndex2-index2+1);index2=newIndex2+1;}}}}

方法二：划分数组（最优解）

classSolution{publicdoublefindMedianSortedArrays(int[]nums1,int[]nums2){// 确保 nums1 是较短的数组，优化时间复杂度if(nums1.length>nums2.length){returnfindMedianSortedArrays(nums2,nums1);}intm=nums1.length,n=nums2.length;intleft=0,right=m;// 在 nums1 上二分查找划分点 iintmedian1=0,median2=0;// 中位数候选值while(left<=right){// i: nums1 左半部分的元素个数// j: nums2 左半部分的元素个数inti=(left+right)/2;intj=(m+n+1)/2-i;// 处理边界：用极值代替不存在的元素intnums1LeftMax=(i==0)?Integer.MIN_VALUE:nums1[i-1];intnums1RightMin=(i==m)?Integer.MAX_VALUE:nums1[i];intnums2LeftMax=(j==0)?Integer.MIN_VALUE:nums2[j-1];intnums2RightMin=(j==n)?Integer.MAX_VALUE:nums2[j];if(nums1LeftMax<=nums2RightMin){// 找到合适的划分median1=Math.max(nums1LeftMax,nums2LeftMax);// 左半最大值median2=Math.min(nums1RightMin,nums2RightMin);// 右半最小值left=i+1;// 尝试更大的 i（找最大满足条件的 i）}else{// i 太大，需要减小right=i-1;}}// 根据总长度奇偶性返回结果return(m+n)%2==0?(median1+median2)/2.0:median1;}}

五、代码分析

方法一详解

核心逻辑：排除不可能的元素

• 为什么可以排除k/2个元素？
  假设A[k/2-1] < B[k/2-1]，则A[0..k/2-1]中的每个元素都 ≤A[k/2-1]，而B[0..k/2-2]中的每个元素都 ≤B[k/2-2] < B[k/2-1]。
  因此，比A[k/2-1]小的元素最多有(k/2-1) + (k/2-1) = k-2个 →A[k/2-1]最多是第k-1小的元素，不可能是第 k 小。

边界处理

• 数组越界：用Math.min(index + half, len) - 1确保不越界；
• 一个数组为空：直接返回另一个数组的第 k 个元素；
• k=1：返回两个数组当前首元素的最小值。

方法二详解

划分思想

目标：找到i和j，使得：

• i + j = (m + n + 1) / 2（左半部分长度）
• nums1[i-1] <= nums2[j]且nums2[j-1] <= nums1[i]

为什么交换数组？

• 确保m <= n，使得j = (m+n+1)/2 - i >= 0；
• 时间复杂度从O(log(m+n))优化到O(log min(m,n))。

边界处理

• i=0→nums1左半为空 →nums1LeftMax = -∞
• i=m→nums1右半为空 →nums1RightMin = +∞
• 同理处理j=0和j=n

六、时间复杂度和空间复杂度分析

✅ 两种方法均满足题目要求，方法二更优。

七、问题解答（常见疑问）

Q1：为什么方法一中k要减去(newIndex - index + 1)？

因为排除了index到newIndex（包含）共(newIndex - index + 1)个元素，这些元素都小于第 k 小的元素，所以新的第 k 小元素在剩余元素中是第k - count小的。

Q2：方法二中为什么j = (m + n + 1) / 2 - i？

• 总长度L = m + n
• 左半部分长度应为(L + 1) / 2（向上取整）
• 因为i + j = (L + 1) / 2→j = (L + 1) / 2 - i

Q3：能否用归并排序的思想？

可以，但时间复杂度O(m+n)，不符合要求。仅适用于不要求O(log n)的场景。

Q4：为什么方法二要找“最大的 i”满足nums1[i-1] <= nums2[j]？

因为我们要确保左半部分尽可能大（从而右半部分尽可能小），这样才能正确计算中位数。最大的i对应最优划分。

八、优化思路

优化1：提前终止（微优化）

在方法一中，若一个数组已遍历完，可直接返回结果，无需继续循环。

优化2：位运算加速（不推荐）

mid = (left + right) >>> 1可防溢出，但本题数据范围小，无需。

优化3：模板化（工程实践）

将getKthElement封装为通用工具函数，支持任意 k 值：

publicstaticintfindKthSmallest(int[]A,int[]B,intk){// 实现...}

九、数据结构与算法基础知识点回顾

1. 中位数的数学性质

• 将集合划分为两个等长（或差1）的子集；
• 左子集最大值 ≤ 右子集最小值。

2. 二分查找的高级应用

• 标准二分：查找目标值；
• 第 k 小元素：通过排除法缩小搜索空间；
• 划分问题：通过性质判断调整搜索方向。

3. 边界处理技巧

• 用Integer.MIN_VALUE和Integer.MAX_VALUE处理空区间；
• 用Math.min防止数组越界。

4. 复杂度分析

• log(m+n)vslog min(m,n)：后者更优，尤其当一个数组很小时。

十、面试官提问环节（模拟对话）

面试官：你的方法一中，为什么比较nums1[k/2-1]和nums2[k/2-1]？

✅回答：因为这两个位置之前的元素各有k/2-1个，总共k-2个。较小值最多是第k-1小的元素，所以可以安全排除它及其前面的所有元素。

面试官：方法二的时间复杂度为什么是O(log min(m,n))？

✅回答：因为我们总是在较短的数组上进行二分查找，搜索空间大小为min(m,n)，每次迭代将空间减半，所以是O(log min(m,n))。

面试官：如果允许重复元素，算法还有效吗？

✅回答：有效。因为我们的比较逻辑（<=）已经处理了相等情况，重复元素不会影响排除逻辑。

面试官：能否推广到找第 k 小的元素（k 任意）？

✅回答：方法一本身就是为找第 k 小设计的。方法二需要调整划分条件，但核心思想仍适用。

十一、这道算法题在实际开发中的应用

1. 分布式数据库的跨分片查询

• 数据按范围分片存储在不同节点；
• 查询中位数时，需在多个有序分片中高效定位，避免全量拉取。

2. 流数据统计

• 实时数据流分成多个有序缓冲区；
• 动态计算中位数用于异常检测或指标监控。

3. 多源数据融合

• 来自不同传感器的数据已分别排序；
• 快速计算整体中位数用于决策系统。

4. 大数据 Top-K 查询

• 在 MapReduce 中，各 reducer 输出有序列表；
• 最终合并时需高效找到全局中位数。

5. 金融风控系统

• 不同渠道的交易金额已排序；
• 实时计算中位数用于风险评分。

十二、相关题目推荐

🔔 学习路径建议：34 → 33 → 4 → 378

十三、总结与延伸

核心思想总结

1. 问题转化：中位数 → 第 k 小元素；
2. 排除法：每次排除k/2个不可能的元素；
3. 划分思想：通过数学性质直接定位中位数；
4. 边界处理：用极值和越界检查确保鲁棒性。

延伸思考

• 如果数组未排序？
  → 需先排序，时间复杂度至少O((m+n) log(m+n))。

• 如果内存受限？
  → 方法一更优，因为它不需要额外空间，且可流式处理。

• 能否并行化？
  → 方法二的二分过程难以并行，但方法一的排除步骤可部分并行。

工程建议

• 在生产代码中，优先选择方法一（更易理解和维护）；
• 在面试中，先实现方法一，再尝试方法二展示深度；
• 始终写测试用例：覆盖空数组、单元素、奇偶长度等情况。

结语

“寻找两个正序数组的中位数”是一道集数学洞察、算法技巧和工程实现于一体的经典难题。它不仅考察你对二分查找的掌握，更检验你在面对复杂约束时的问题转化能力。

正如计算机科学家 Niklaus Wirth 所言：“算法 + 数据结构 = 程序。” 本题正是这一公式的完美体现——通过精巧的算法设计，在不改变数据结构的前提下，实现了理论最优的时间复杂度。

✨练习建议：

1. 手写两种方法，确保理解每行逻辑；
2. 尝试修改为找第 k 小的元素（k 任意）；
3. 思考如何处理重复元素（虽然本题已支持）。

掌握这道题，你就掌握了在“有序世界”中高效统计的算法精髓。