leetcode（4.寻找两个正序数组的中位数）【困难】官解——二分查找

一、题目

给定两个大小分别为 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
• -106 <= nums1[i], nums2[i] <= 106

二、题解

不需要合并两个有序数组，只要找到中位数的位置即可。
由于两个数组的长度已知，因此中位数对应的两个数组的下标之和也是已知的。
维护两个指针，初始时分别指向两个数组的下标0的位置，每次将指向较小值的指针后移一位（如果一个指针已经到达数组末尾，则只需要移动另一个数组的指针），直到到达中位数的位置。
根据中位数的定义，

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

因此，这道题可以转化成寻找两个有序数组中的第$k$小的数，其中$k$为$(m+n)/2$或$(m+n)/2+1$。

假设两个有序数组分别是A和B。要找到第$k$个元素，我们可以比较 $A_{[k/2-1]}$和 $B_{[k/2-1]}$,其中 / 表示整数除法。由于$A_{[k/2-1]}$和$B_{[k/2-1]}$的前面分别有 $A_{[\mathrm{0..}k/2-2]}$和$B_{[\mathrm{0..}k/2-2]}$，即：$k/2-1$个元素，对于$A_{[k/2-1]}$ 和 $B_{[k/2-1]}$中的较小值，最多只会有 $(k/2-1)+(k/2-1)\le k-2$ 个元素比它小，那么它就不能是第 $k$小的数了。

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

• 如果 $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/2$个不可能是第$k$小的数，查找范围缩小了一半。同时，我们将在排除后的新数组上继续进行二分查找，并且根据我们排除数的个数，减少$k$ 的值，这是因为我们排除的数都不大于第$k$ 小的数。

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

• 如果$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_{[2]}>B_{[2]}$，因此排除$B_{[0]}$到$B_{[2]}$，即数组B的下标偏移（offset）变为3,同时更新k的值：$k=k-k/2=4$。

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

由于$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_{[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$

三、代码

   public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        // java版官解
        int len1 = nums1.length, len2 = nums2.length;
        int totalLength = len1 + len2;
        if (totalLength % 2 == 1) {
            int midIndex = totalLength / 2;
            double median = getKthElement(nums1, nums2, midIndex + 1);
            return median;
        } else {
            int midIndex1 = totalLength / 2 - 1, midIndex2 = totalLength / 2;
            double median = (getKthElement(nums1, nums2, midIndex1 + 1) + getKthElement(nums1, nums2, midIndex2 + 1)) / 2.0;
            return median;
        }
    }

    public int getKthElement(int[] nums1, int[] nums2, int k) {
        /* 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
         * 这里的 "/" 表示整除
         * nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
         * nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
         * 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
         * 这样 pivot 本身最大也只能是第 k-1 小的元素
         * 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
         * 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
         * 由于我们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数
         */

        int length1 = nums1.length, length2 = nums2.length;
        int index1 = 0, index2 = 0;
        int kthElement = 0;

        while (true) {
            // 边界情况
            if (index1 == length1) {
                return nums2[index2 + k - 1];
            }
            if (index2 == length2) {
                return nums1[index1 + k - 1];
            }
            if (k == 1) {
                return Math.min(nums1[index1], nums2[index2]);
            }

            // 正常情况
            int half = k / 2;  // 每一个数组拿中位数角标的一半
            int newIndex1 = Math.min(index1 + half, length1) - 1;
            int newIndex2 = Math.min(index2 + half, length2) - 1;
            int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];
            if (pivot1 <= pivot2) {
                k -= (newIndex1 - index1 + 1);
                index1 = newIndex1 + 1;
            } else {
                k -= (newIndex2 - index2 + 1);
                index2 = newIndex2 + 1;
            }
        }
    }

四、结果

五、说明

  本文章仅用于记录个人做题记录
  由于本人是个小菜鸡（实锤），题目解法并非最优，且解题过程中参考（抄袭）各大佬解题方法，望见谅。