LeetCode.H4.寻找两个正序数组的中位数-CSDN博客

本文链接：https://blog.csdn.net/a695484357/article/details/126354690

LeetCode.H4

题目：

在这里插入图片描述

题目大意：

给定两个升序数组，求这两个数组合并后的中位数。时间复杂度要求为O(log(n + m))。

数据范围：

如图所示

思路：

根据中位数的定义:

当 m + n 是奇数时，中位数是两个有序数组中的第 (m + n + 1) / 2 个元素。
当 m + n 是偶数时，中位数是两个有序数组中的第 (m + n + 1) / 2 个元素和第 (m + n + 2) / 2 个元素的平均值。

特别注意，当 m + n 是奇数时，第 (m + n + 1) / 2 个元素和第 (m + n + 2) / 2 是同一个元素，因此，我们不管 m + n 是奇数还是偶数，只要求出第 (m + n + 1) / 2 个元素和第 (m + n + 2) / 2 个元素的和的平均值，该值即为我们要求的中位数。

因为我们时间复杂度要求是O(log(n + m))的，可以想到用“二分”来做，即每次处理只处理一半的区间。

假设两个有序数组分别是 A 和 B。要找到第 k 个元素，我们可以比较 A[k / 2 − 1] 和 B[k / 2 − 1]，其中 / 表示整数除法。由于 A[k / 2 − 1] 和 B[k / 2 − 1] 的前面分别有 A[0…k / 2 − 2] 和 B[0…k / 2 − 2]，即 k / 2 − 1 个元素，对于 A[k / 2 − 1] 和 B[k / 2 − 1] 中的较小值，最多只会有 (k / 2 - 1)+(k / 2 - 1) ≤ k − 2 个元素比它小，那么它就不能是第 k 小的数了（最多是第k - 1小的数）。因此就可以抛弃该较小值和它前面的数。

因此我们可以归纳出三种情况：

如果 A[k / 2 − 1]<B[k / 2 − 1]，则比 A[k / 2 − 1] 小的数最多只有 A 的前 k / 2 − 1 个数和 B 的前 k / 2 − 1 个数，即比 A[k / 2 − 1] 小的数最多只有 k − 2 个，因此 A[k / 2 − 1] 不可能是第 k 个数，A[0] 到 A[k / 2 − 1] 也都不可能是第 k 个数，可以全部排除。
如果 A[k / 2 − 1]>B[k / 2 − 1]，则可以排除 B[0] 到 B[k / 2 − 1]的数。
如果 A[k / 2 − 1]=B[k / 2 − 1]，则可以归入第一种情况处理。

有以下三种情况需要特殊处理：

如果 A[k / 2 − 1] 或者 B[k / 2 − 1] 越界，那么我们可以选取对应数组中的最后一个元素。在这种情况下，我们必须根据排除数的个数减少 k 的值，而不能直接将 k 减去 k / 2。
如果一个数组为空，说明该数组中的所有元素都被排除，我们可以直接返回另一个数组中第 k 小的元素。
如果 k = 1，我们只要返回两个数组首元素的最小值即可。

用一个例子说明上述算法。假设两个有序数组如下：

A: 1 3 4 9
B: 1 2 3 4 5 6 7 8 9

两个有序数组的长度分别是 4 和 9，长度之和是 13，中位数是两个有序数组中的第 7 个元素，因此需要找到第 k = 7 个元素。

比较两个有序数组中下标为 k / 2 − 1 = 2 的数，即 A[2] 和 B[2]，如下面所示：

A: 1 3 4 9
       ↑
B: 1 2 3 4 5 6 7 8 9
       ↑

由于A[2] > B[2]，因此排除 B[0] 到 B[2]，即数组 B 的下标偏移变为 3，同时更新 k 的值：k = k − k / 2 = 4。

下一步寻找，比较两个有序数组中下标为 k / 2 − 1 = 1 的数，即 A[1] 和 B[4]，如下面所示，其中方括号部分表示已经被排除的数。

A: 1 3 4 9
     ↑
B: [1 2 3] 4 5 6 7 8 9
           ↑

由于 A[1]<B[4]，因此排除 A[0] 到 A[1]，即数组 A 的下标偏移变为 2，同时更新 k 的值：k = k − k / 2 = 2。

下一步寻找，比较两个有序数组中下标为 k / 2 − 1 = 0 的数，即比较 A[2] 和 B[3]，如下面所示，其中方括号部分表示已经被排除的数。

A: [1 3] 4 9
         ↑
B: [1 2 3] 4 5 6 7 8 9
           ↑

由于A[2] = B[3]，根据之前的规则，排除 A 中的元素，因此排除 A[2]，即数组 A 的下标偏移变为 3，同时更新 k 的值：k = k − k / 2 = 1。

由于 k 的值变成 1，因此比较两个有序数组中的未排除下标范围内的第一个数，其中较小的数即为第 k 个数，由于A[3] > B[3]，因此第 k 个数是 B[3] = 4。

A: [1 3 4] 9
           ↑
B: [1 2 3] 4 5 6 7 8 9
           ↑

代码：

class Solution {
    public double getKthNum(int[] nums1, int[] nums2, int k){
        int i = 0, j = 0;
        while (true){
            if (i >= nums1.length)
                return nums2[j + k - 1];
            if (j >= nums2.length)
                return nums1[i + k - 1];
            if (k == 1)
                return Math.min(nums1[i], nums2[j]);
            int half = k / 2;
            int idx1 = Math.min(i + half - 1, nums1.length - 1);
            int idx2 = Math.min(j + half - 1, nums2.length - 1);
            int p1 = nums1[idx1], p2 = nums2[idx2];
            if (p1 <= p2){
                k -= (idx1 - i + 1);
                i = idx1 + 1;
            }else {
                k -= (idx2 - j + 1);
                j = idx2 + 1;
            }
        }
    }

    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n = nums1.length, m = nums2.length;
        double a = getKthNum(nums1, nums2, (n + m + 1) / 2);
        double b = getKthNum(nums1, nums2, (n + m + 2) / 2);
        return (a + b) / 2;
    }
}
public class Main {
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums1 = new int[]{1,2};
        int[] nums2 = new int[]{3,4};
        System.out.println(solution.findMedianSortedArrays(nums1, nums2));
    }
}