LeetCode每日一题(4. Median of Two Sorted Arrays)_median of two sorted arrays hard 22.1k 2.5k compan-优快云博客

这是一篇关于解决LeetCode中‘两排序数组的中位数’问题的文章。通过O(log(m+n))的时间复杂度，找到两个已排序数组的中位数。例如，当nums1=[1,3]，nums2=[2]时，合并后的数组为[1,2,3]，中位数是2。文章介绍了一种策略，通过找到一个数组的中点，再用二分查找确定其在另一数组中的位置，从而高效地合并数组并计算中位数。" 110734290,8070352,C++虚函数与多态实践解析,"['C++', '面向对象', '继承', '多态性']

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.

The overall run time complexity should be O(log (m+n)).

Example 1:

Input: nums1 = [1,3], nums2 = [2]
Output: 2.00000

Explanation: merged array = [1,2,3] and median is 2.

Example 2:

Input: nums1 = [1,2], nums2 = [3,4]
Output: 2.50000

Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.

Constraints:

nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106

其实就是实现一个快速排序，只是我们需要根据两个数组各自的中点在对方数组中的位置决定如何进行合并，具体的方法是找到一个数组的中点，然后二分搜索另一个数组中第一个大于该值的位置，然后根据位置来决定是如何进行合并


impl Solution {
    fn binary_split(nums: Vec<i32>, target: i32) -> (Vec<i32>, Vec<i32>) {
        let mut l = 0;
        let mut r = nums.len();
        while l < r {
            let m = (l + r) / 2;
            if nums[m] < target {
                l = m + 1;
                continue;
            }
            r = m;
        }
        (nums[..l].to_vec(), nums[l..].to_vec())
    }

    fn merge(mut nums1: Vec<i32>, mut nums2: Vec<i32>) -> Vec<i32> {
        if nums1.is_empty() {
            return nums2;
        }
        if nums2.is_empty() {
            return nums1;
        }
        if nums1[nums1.len() - 1] <= nums2[0] {
            nums1.append(&mut nums2);
            return nums1;
        }
        if nums2[nums2.len() - 1] <= nums1[0] {
            nums2.append(&mut nums1);
            return nums2;
        }
        let mid1 = nums1[nums1.len() / 2];
        let (left2, right2) = Solution::binary_split(nums2.clone(), mid1);
        if right2.is_empty() {
            let mid2 = nums2[nums2.len() / 2];
            let (left1, right1) = Solution::binary_split(nums1, mid2);
            let mut left = Solution::merge(nums2[..nums2.len() / 2].to_vec(), left1);
            let mut right = Solution::merge(nums2[nums2.len() / 2..].to_vec(), right1);
            left.append(&mut right);
            return left;
        }

        let mut left = Solution::merge(nums1[..nums1.len() / 2].to_vec(), left2);
        let mut right = Solution::merge(nums1[nums1.len() / 2..].to_vec(), right2);
        left.append(&mut right);
        left
    }
    pub fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
        let l = Solution::merge(nums1, nums2);
        if l.len() % 2 == 0 {
            return (l[l.len() / 2 - 1] + l[l.len() / 2]) as f64 / 2.0;
        }
        l[l.len() / 2] as f64
    }
}