LeetCode 4. 寻找两个正序数组的中位数（多解法）

解法一：合并数组

将两个数组合并后，直接根据下标找到中位数。时间复杂度$O(m+n)$，空间复杂度 $O(m+n)$

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n = nums1.length, m = nums2.length;
        int[] mix = new int[n + m];
        // 先执行数组合并
        int i = 0, j = 0, k = 0;
        while (i < n && j < m) {
            if (nums1[i] <= nums2[j]) mix[k++] = nums1[i++];
            else mix[k++] = nums2[j++];
        }
        while (i < n) mix[k++] = nums1[i++];
        while (j < m) mix[k++] = nums2[j++];
        // 合并完毕, 直接找到中位数的下标
        if ((n + m) % 2 == 0) {
            return (mix[(n + m) / 2 - 1] + mix[(n + m) / 2]) / 2.0;
        } else {
            return mix[(n + m) / 2];
        }
    }
}

解法二：双指针

无需合并两个数组，只需要用双指针进行比较并移动到对应位置即可。时间复杂度$O(m+n)$，空间复杂度 $O(1)$

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n = nums1.length, m = nums2.length;
        // 当 n + m 是偶数时, left, right是中间两个位置
        // 当 n + m 是奇数时, left, right是同一个位置 
        int left = (n + m + 1) / 2;
        int right = (n + m + 2) / 2;
        int cnt = 1; // 当前需要取第几个数
        int median1 = 0, median2 = 0; // 第一个, 第二个位置的数
        int i = 0, j = 0; // 双指针
        while (cnt <= right) {
            int min = 0; // 当前这一轮取到的较小的值
            if (i < n && (j >= m || nums1[i] <= nums2[j])) min = nums1[i++];
            else min = nums2[j++];
            if (cnt == left) median1 = min;
            if (cnt == right) median2 = min;
            cnt++;
        }
        return (median1 + median2) / 2.0;
    }
}

解法三：二分

求两个有序数组的中位数，可以变换为，求第k个数。由于两个数组有序，我们每次只要从两个数组中，分别从左取k/2个数，然后想象尝试将这2组k/2个数合并。若第1组的最后一个数，小于第2组的最后一个数，则第1组不可能作为第k个数，那么可以将第1组的k/2个数全部排除。时间复杂度 $O(log(m+n))$，空间复杂度 $O(1)$

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n = nums1.length, m = nums2.length;
        int left = (n + m + 1) / 2;
        int right = (n + m + 2) / 2;
        int median1 = getKth(nums1, 0, nums2, 0, left);
        int median2 = getKth(nums1, 0, nums2, 0, right);
        return (median1 + median2) / 2.0;
    }

    // 递归写法
    // 从nums1的下标i开始, 从nums2的下标j开始, 找第k个数
    private int getKth(int[] nums1, int i, int[] nums2, int j, int k) {
        int n = nums1.length, m = nums2.length;
        // 退出条件
        if (i >= n) return nums2[j + k - 1];
        if (j >= m) return nums1[i + k - 1];
        if (k == 1) return Math.min(nums1[i], nums2[j]);
        // 开始二分
        // 从 nums1 中取 k / 2 个数, 并获得其最后一个点, 注意不能越界
        int ie = Math.min(i + k / 2 - 1, n - 1);
        // 从 nums2 中取 k / 2 个数, 并获得其最后一个点
        int je = Math.min(j + k / 2 - 1, m - 1);
        
        if (nums1[ie] <= nums2[je]) {
            // 排除 nums1 的 k / 2个数
            return getKth(nums1, ie + 1, nums2, j, k - (ie - i + 1));
        } else {
            return getKth(nums1, i, nums2, je + 1, k - (je - j + 1));
        }
    }
}

针对getKth方法，再提供一个非递归的写法

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n = nums1.length, m = nums2.length;
        int left = (n + m + 1) / 2;
        int right = (n + m + 2) / 2;
        int median1 = getKth(nums1, nums2, left);
        int median2 = getKth(nums1, nums2, right);
        return (median1 + median2) / 2.0;
    }

    private int getKth(int[] nums1, int[] nums2, int k) {
        int n = nums1.length, m = nums2.length;
        int i = 0, j = 0;
        while (i < n && j < m && k > 1) {
            int ie = Math.min(i + k / 2 - 1, n - 1);
            int je = Math.min(j + k / 2 - 1, m - 1);
            if (nums1[ie] <= nums2[je]) {
                k -= (ie - i + 1); // 更新k
                i = ie + 1; // 更新i, 注意不要先更新i, 再更新 k 
            } else {
                k -= (je - j + 1);
                j = je + 1;
            }
        }

        if (i >= n) return nums2[j + k - 1];
        if (j >= m) return nums1[i + k - 1];
        return Math.min(nums1[i], nums2[j]);
    }
}

解法三：进阶二分（划分数组）

对于数组nums1，其长度为n；数组nums2，其长度为m。

对于nums1，我们从中间切开，将其划分为左右两个数组；对于nums2同理。

将nums1和nums2的左半边数组，合并在一起，称为leftPart；将它们的右半边数组，合并在一起，称为rightPart。

只需要保证：

• len(leftPart) == len(rightPart)（总长度为偶数时），len(leftPart) = len(rightPart) + 1 （总长度为奇数时）
• max(leftPart) <= min(rightPart)

只需要保证上面的两个条件，则中位数为 (max(leftPart) + min(rightPart)) / 2 （总长度为偶数），或max(leftPart)（总长度为奇数）

接下来我们来看，有多少种划分方式。对于数组nums1，根据其左半边数组的大小，容易得知，共有n + 1种划分方式（即，其左半边数组长度为0，1，2，…，n）；对于nums2同理。

我们设i表示某种划分方式下，nums1的左半边数组的大小；设j为某种划分方式下，nums2的左半边数组的大小。

则len(leftPart) = i + j，len(rightPart) = n + m - (i + j)

要保证上方的第一个条件。只需要保证 i + j = n + m - (i + j)，或 i + j = n + m - (i + j) + 1

变换一下，得 i + j = (n + m + 1) / 2（除法采用向下取整，可兼容长度为偶数和奇数的情况）

由于 max(leftPart) = max(nums1[i], nums2[j])，而min(rightPart) = min(nums1[i + 1], nums2[j + 1])

要保证 max(leftPart) <= min(rightPart)，只需要保证 nums1[i] <= nums2[j + 1]，并且 nums2[j] <= nums1[i + 1]

由于i和j需要满足 i + j = (n + m + 1) / 2，可知i和j是呈负相关的。

那么只需要找到，使得 nums1[i] <= nums2[j + 1]成立的最大的i，即可。因为只要i多1，则j必然少1。那么最大的i，满足nums1[i] <= nums2[j + 1]，也就蕴含了 nums1[i + 1] >= nums2[j]。

所以我们只需要进行二分，找到满足nums1[i] <= nums2[j + 1]的最大的i即可。

对于j的计算，对上面的公式进行变换，得 j = (n + m + 1) / 2 - i，为了使得j不取到负数，当i取最大值n时，

j = (m - n + 1) / 2，我们规定m >= n，即nums2得长度大于等于nums1。

由于我们总是对较小的数组进行二分，所以时间复杂度是 $O(log(min(n,m)))$，空间复杂度为 $O(1)$

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n = nums1.length, m = nums2.length;
        // i + j = (n - i) + (m - j)      总长度为偶数
        // i + j = (n - i) + (m - j) + 1  奇数, 让左侧区间多出一个数
        // i + j = (n + m + 1) / 2        i和j需要满足的关系
        // i = (n + m + 1) / 2 - j        // 需要保证 i >= 0 , 则 n >= m
        if (n < m) return findMedianSortedArrays(nums2, nums1);

        // 开始二分, 对 j 进行二分
        int l = 0, r = m;
        int median1 = 0, median2 = 0;
        while (l <= r) { // 写成 = 确保能二分到最后
            int j = l + r >> 1;
            int i = (n + m + 1) / 2 - j;
            // nums2 左半边的最后一个值 (注意对于j = 0 进行特殊处理)
            int nums2_j = j == 0 ? Integer.MIN_VALUE : nums2[j - 1];
            // nums2 右半边的第一个值 (注意对 j = m 进行特殊处理)
            int nums2_j_1 = j == m ? Integer.MAX_VALUE : nums2[j];

            int nums1_i = i == 0 ? Integer.MIN_VALUE : nums1[i - 1];
            int nums1_i_1 = i == n ? Integer.MAX_VALUE : nums1[i];

            if (nums2_j <= nums1_i_1) {
                median1 = Math.max(nums2_j, nums1_i);
                median2 = Math.min(nums2_j_1, nums1_i_1);
                l = j + 1; // 往右侧找, 直接跳过当前位置, 确保二分的循环能退出去
            } else {
                r = j - 1; // 往左侧找
            }
        }
        if ((n + m) % 2 == 0) return (median1 + median2) / 2.0;
        else return median1;
    }
}

二分的时候，条件我们写成 l <= r，确保能二分到最后的位置，更新边界时，我们每次都跳过当前位置，即不会更新为l = j这样。确保二分的循环能退出，并且在每次满足条件时，都更新median1和median2，记录答案。