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

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

​ 题目描述

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。

请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

​ 示例

nums1 = [1, 3]，nums2 = [2]，则中位数是 2.0
nums1 = [1, 2]，nums2 = [3, 4]，则中位数是 (2 + 3)/2 = 2.5

1：暴力解法

也是归并排序的组合部分。

这个时候我们先不要求解出本题的时间复杂度为：O(log(m+n))

• 中位数：最中间的那个数（该数的左右个数相同）
• 既然给出了两个正序数组，我们可以将这两个正序数组合成为一个正序的数组
• 判断合成后的数组的长度为奇数还是偶数，进而求出中位数

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int len1 = nums1.length;
        int len2 = nums2.length;
        // 合成的数组
        int[] res = new int[len1+len2];
        int index = 0;
        int left = 0, right = 0;
        // 归并排序合成部分
        while(left<len1&&right<len2) {
            if(nums1[left]<nums2[right]) {
                res[index++] = nums1[left++];
            } else {
                res[index++] = nums2[right++];
            }
        }
        // 判断nums1剩余还是nums2剩余，并将剩余部分加入到合成的数组之后
        while(left<len1) {
            res[index++] = nums1[left++];
        }
        while(right<len2) {
            res[index++] = nums2[right++];
        }
        // 判断合成后的数组的长度，求出中位数。返回的是double类型
        if((len1+len2)%2==1) {
            return (double) res[(len1+len2)/2];
        } else {
            return (double) (res[(len1+len2)/2]+res[(len1+len2)/2-1])/2;
        }
    }
}

时间复杂度：O(m+n)，空间复杂度：O(m+n)

2：暴力解法优化

在暴力解法中，我们新创建了一个数组用来找到中位数。

考虑到中位数与两个数组长度之和有关，所以我们可以直接通过两个指针来定位中位数的位置。

此时，没有创建新的数组，所以空间复杂度降低到：O(1)

• 两个数组长度和为奇数：只需要知道第len/2+1个数就可以了。即：遍历len/2+1次。要知道第len/2+1个数，即：需要最后一次遍历即可。
• 两个数组长度和为偶数：则需要知道第len/2与len/2+1个数。即：遍历len/2+1次。此时需要记录第len/2个数

public double findMedianSortedArrays(int[] A, int[] B) {
    int m = A.length;
    int n = B.length;
    int len = m + n;
    // left用来保存上一次遍历的结果，right表视当前遍历的结果。因为偶数时：需要两个值
    int left = -1, right = -1;
    // aStart指向此时A数组的位置，bStart指向此时B数组的位置
    int aStart = 0, bStart = 0;
    for (int i = 0; i <= len / 2; i++) {
        // 每次开始新的一边遍历时，保存上次的遍历结果
        left = right;
        // 数组A指针aStart后移的条件：aStart没有到A的最后，此时A位置的数字小于B位置的数字。此时要判断B的指针bStart是否越界，如果越界的话就不去判断此时A位置的值与B位置的值的大小，而是继续遍历A当前位置的值。
        if (aStart < m && (bStart >= n || A[aStart] < B[bStart])) {
            right = A[aStart++];
        } else {
            right = B[bStart++];
        }
    }
    if ((len & 1) == 0)
        return (left + right) / 2.0;
    else
        return right;
}

时间复杂度：O(m+n)，空间复杂度：O(1)

3：二分法

暴力解法对于本题来说不满足时间复杂度，要求时间复杂度为O(log(m+n))，所以自然想到了二分法。

先理解：两个数组长度为奇数：中位数就是第(m+n)/2+1小元素；两个数组长度为偶数：中位数是第(m+n)/2小与第(m+n)/2+1小元素的和的一半

那么，如何求出两个数组中第k小的元素？

1. 找到两个数组中的第k小元素。即：第一个数组中的某个位置k/2，第二个数组中某个位置k/2
2. 如果nums1[k/2]<nums2[k/2]，那么此时nums2[0]...nums2[k/2]都不是第k小。故：我们应该从nums1[0]...nums1[k/2]与nums2[k/2]...nums2[len2-1]
3. 解释2：nums1数组中比 nums1[k/2]小的数有 k/2-1个，nums2 数组中，nums2[k/2] 比 nums1[k/2] 小， nums2[k/2] 前边的数字都比 nums1[k/2] 小，只有 k/2-1 个，所以比nums1[k/2] 小的数字最多有 k/2-1+k/2-1=k-2个，所以 nusm1[k/2] 最多是第k-1小的数。而比 nums1[k/2] 小的数更不可能是第 k 小的数了，所以可以把它们排除。
4. 此时已经排除了k/2个数了。故：此时要更新k的值。在num1[0]...nums1[len1-1]与nums2[k/2]...nums2[len2-1]中递归查找第k小的值

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    int n = nums1.length;
    int m = nums2.length;
    int left = (n + m + 1) / 2;
    int right = (n + m + 2) / 2;
    //将偶数和奇数的情况合并，如果是奇数，会求两次同样的 k 。
    return (getKth(nums1, 0, n - 1, nums2, 0, m - 1, left) + getKth(nums1, 0, n - 1, nums2, 0, m - 1, right)) * 0.5;  
}
    
private int getKth(int[] nums1, int start1, int end1, int[] nums2, int start2, int end2, int k) {
    int len1 = end1 - start1 + 1;
    int len2 = end2 - start2 + 1;
    //让 len1 的长度小于 len2，这样就能保证如果有数组空了，一定是 len1 
    if (len1 > len2) return getKth(nums2, start2, end2, nums1, start1, end1, k);
    if (len1 == 0) return nums2[start2 + k - 1];

    if (k == 1) return Math.min(nums1[start1], nums2[start2]);

    int i = start1 + Math.min(len1, k / 2) - 1;
    int j = start2 + Math.min(len2, k / 2) - 1;

    if (nums1[i] > nums2[j]) {
        return getKth(nums1, start1, end1, nums2, j + 1, end2, k - (j - start2 + 1));
    }
    else {
        return getKth(nums1, i + 1, end1, nums2, start2, end2, k - (i - start1 + 1));
    }
}

时间复杂度：O(log(m+n))，空间复杂度：O(1)