LeetCode 算法：寻找两个正序数组的中位数 c++

原题链接🔗：寻找两个正序数组的中位数
难度：困难⭐️⭐️⭐️

题目

给定两个大小分别为 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 <= 1000
• 0 <= n <= 1000
• 1 <= m + n <= 2000
• -10⁶ <= nums1[i], nums2[i] <= 10⁶

题解

1. 解题思路：

LeetCode 上的这个问题通常被称为 “Median of Two Sorted Arrays”。这个问题的关键在于两个数组是有序的，这为我们提供了一种有效的方法来找到中位数，而不需要将两个数组合并并排序，这会消耗大量的时间。

• 问题描述

  • 给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(min(m, n)))。

• 解题思路

  • 理解中位数：首先，需要理解中位数的定义。对于两个数组的合并，中位数是将所有元素排序后位于中间位置的数。如果总数是奇数，中位数就是中间的那个数；如果是偶数，中位数是中间两个数的平均值。

  • 二分查找：由于数组是有序的，我们可以使用二分查找来确定中位数的位置。我们的目标是找到一个分割点，使得左边的元素数量和右边的元素数量尽可能接近。

  • 确定分割点：我们可以设置两个指针，分别指向两个数组的起始位置。通过调整这两个指针的位置，我们可以找到一个分割点，使得左边的元素数量等于或比右边的元素数量多一个。

  • 计算中位数：

    • 如果两个数组合并后的总长度是奇数，中位数就是左边所有元素的最大值。
    • 如果是偶数，中位数就是左边最大元素和右边最小元素的平均值。

  • 边界条件：在二分查找的过程中，我们需要考虑一些边界条件，比如当一个数组为空时，或者当分割点超出数组边界时。

  • 优化：由于题目要求时间复杂度为 O(log(min(m, n)))，我们不能简单地遍历数组，而是需要使用二分查找来减少不必要的比较。

• 算法步骤

  • 初始化两个指针，分别指向两个数组的起始位置。
  • 确定一个分割点，使得左边的元素数量尽可能接近 m/2 和 n/2。
  • 根据当前的分割点，计算当前的中位数候选值。
  • 根据当前的中位数候选值，调整指针的位置，使得更接近真实的中位数。
  • 重复步骤2-4，直到找到中位数。

2. c++ demo：

#include <iostream>
#include <vector>
#include <algorithm>

// 函数用于找到两个有序数组的中位数
double findMedianSortedArrays(std::vector<int>& nums1, std::vector<int>& nums2) {
    size_t m = nums1.size(), n = nums2.size();
    if (m > n) { // 确保nums1是较短的数组
        std::swap(nums1, nums2);
        std::swap(m, n);
    }

    size_t total = m + n;
    size_t low = 0, high = m;
    while (low <= high) {
        size_t partitionX = (low + high) / 2;
        size_t partitionY = (total + 1) / 2 - partitionX;

        int maxLeftX = partitionX == 0 ? INT_MIN : nums1[partitionX - 1];
        int minRightX = partitionX == m ? INT_MAX : nums1[partitionX];

        int maxLeftY = partitionY == 0 ? INT_MIN : nums2[partitionY - 1];
        int minRightY = partitionY == n ? INT_MAX : nums2[partitionY];

        if (maxLeftX <= minRightY && maxLeftY <= minRightX) {
            if (total % 2 == 0) {
                return (std::max(maxLeftX, maxLeftY) + std::min(minRightX, minRightY)) / 2.0;
            }
            else {
                return std::max(maxLeftX, maxLeftY);
            }
        }
        else if (maxLeftX > minRightY) {
            high = partitionX - 1;
        }
        else {
            low = partitionX + 1;
        }
    }

    return 0.0; // 这个返回值只是为了满足编译器的要求，实际上不会执行到这里
}

int main() {
    std::vector<int> nums1 = { 1, 3 };
    std::vector<int> nums2 = { 2 };
    double median = findMedianSortedArrays(nums1, nums2);
    std::cout << "The median is: " << median << std::endl;

    nums1 = { 1, 2 };
    nums2 = {};
    median = findMedianSortedArrays(nums1, nums2);
    std::cout << "The median is: " << median << std::endl;

    nums1 = {};
    nums2 = { 1, 2 };
    median = findMedianSortedArrays(nums1, nums2);
    std::cout << "The median is: " << median << std::endl;

    return 0;
}

• 输出结果：

The median is: 2
The median is: 1.5
The median is: 1.5

3. 代码仓库地址：findMedianSortedArrays