LeetCode 4. Median of Two Sorted Arrays【二分+递归+妙啊】⭐⭐⭐⭐⭐

题目描述

知识点

神奇的二分查找！

结果

实现

码前思考：⭐问题转换

题目说的是给两个排好序的数组，让你求出这两个数组中所有元素按从小到大排列，排在中间的元素，时间复杂度也是有要求的，$O(log(m+n))$，$m$ 和 $n$ 分别是这两个数组的长度。

这里提到了时间复杂度为 $O(log(m+n))$ ，很容易想到的就是 二分查找 (看见$O(log)$基本上都要尝试一下二分查找！)，所以现在要做的就是在两个排序数组中进行二分查找。

⭐问题转换
具体思路如下，将问题 转化为在两个有序数组中找第 K 个小的数 。

这里回顾一下，之前做题有总结：遇到求K最小的时候，要想到 堆 ~~
但是这里由于时间复杂度的要求，建堆的时间复杂度就是$O(N)$了，所以不用堆！而是用二分查找。

求中位数，其实就是求第 k 小数的一种特殊情况。

这里假设两个数组为 A ，B。首先在两个数组中分别找出第 k/2 大的数，再比较这两个第 k/2 大的数，由于数列是有序的，我们可以每次排除掉 k/2 个数。

举个例子：
假设我们要找第 7 小的数字。

我们比较两个数组的第 k / 2 个数字，如果 k 是奇数，向下取整。也就是比较第 3 个数字，上边数组中的 4 和 下边数组中的 3 ，如果哪个小，就表明该数组的前 k / 2 个数字都不是第 k 小数字，所以可以排除。也就是 1，2，3 这三个数字不可能是第 7 小的数字，我们可以把它排除掉。将 1349 和 45678910 两个数组作为新的数组进行比较。
橙色的部分表示已经去掉的数字。

由于我们已经排除掉了 3 个数字，就是这 3 个数字一定在最前边，所以在两个新数组中，我们只需要找第 7 - 3 = 4 小的数字就可以了，也就是 k = 4 。此时两个数组，比较第 2 个数字，3 < 5，所以我们可以把小的那个数组中的 1 ，3 排除掉了。

我们又排除掉 2 个数字，所以现在找第 4 - 2 = 2 小的数字就可以了。此时比较两个数组中的第 k / 2 = 1 个数，4 == 4 ，怎么办呢？
由于两个数相等，所以我们无论去掉哪个数组中的都行，因为去掉 1 个总会保留 1 个的，所以没有影响。为了统一，我们就假设 4 > 4 吧，所以此时将下边的 4 去掉。

由于又去掉 1 个数字，此时我们要找第 1 小的数字，所以只需判断两个数组中第一个数字哪个小就可以了，也就是 4 。

所以第 7 小的数字是 4 。

我们每次都是取 k / 2 的数进行比较，有时候可能会遇到数组长度小于 k / 2 的时候。

此时 k / 2 等于 3 ，而上边的数组长度是 2 ，我们此时将箭头指向它的末尾就可以了（因为我们的思想反正是寻找剩余的数组中的第k个，就算这次不是k/2，但是并不影响我们后面的求解！）。这样的话，由于 2 < 3 ，所以就会导致上边的数组 1，2 都被排除。造成下边的情况。

由于 2 个元素被排除，所以此时 k = 5 ，又由于上边的数组已经空了，我们只需要返回下边的数组的第 5 个数字就可以了。

从上边可以看到，无论是找第奇数个还是第偶数个数字，对我们的算法并没有影响，而且在算法进行中，k 的值都有可能从奇数变为偶数，最终都会变为 1 或者由于一个数组空了，直接返回结果。

所以我们采用递归的思路，为了防止数组长度小于 k / 2 ，所以每次比较 min ( k / 2，len ( 数组 ) )对应的数字，把小的那个对应的数组的数字排除，将两个新数组进入递归，并且 k 要减去排除的数字的个数。递归出口就是当 k = 1 或者其中一个数字长度是 0 了。

代码实现

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        //得到两个数组的长度
        int len1 = nums1.size();
        int len2 = nums2.size();

        //合并总长度为奇数和总长度为偶数的情况，也就是即使总长度为奇数，也计算两次！
        int left = (len1+len2+1)/2;
        int right = (len1+len2+2)/2;

        //记得是除以2.0，这样才会得到浮点数！
        return (getKth(nums1,0,len1-1,nums2,0,len2-1,left)+getKth(nums1,0,len1-1,nums2,0,len2-1,right))/2.0;
    }

    //递归函数的意义是：在nums1[start1:]和nums2[start2:]两个数组间找到第K大的数字
    //递归边界是：k=1，或者某一个数组为空了！
    //注意使用引用，这样速度会快些！
    int getKth(vector<int>& nums1,int start1,int end1,vector<int>& nums2,int start2,int end2,int k){
        int len1 = end1-start1+1;
        int len2 = end2-start2+1;
        
        //递归边界之1
        if(len1 == 0){  //如果此时len1为0，注意：两者只可能有一个为0，不可能两者同时为0，具体思考一下就好了！
            return nums2[start2+k-1];
        }else if(len2 == 0){ //如果此时len2为0
            return nums1[start1+k-1];
        }

        //递归边界之2
        //k等于1的话
        if( k== 1){
            return min(nums1[start1],nums2[start2]);
        }

        //递归式
        //考虑k/2会大于某一个长度的情况
        //首先得到len1，len2和k/2中的最小值
        int i = start1 + min(len1,k/2) - 1;
        int j = start2 + min(len2,k/2) - 1;

        if(nums1[i] > nums2[j]){
            return getKth(nums1,start1,end1,nums2,j+1,end2,k-(j-start2+1));
        }else{  //就算是nums1[i] == nums2[j]，我们默认取其中一种情况就好
            return getKth(nums1,i+1,end1,nums2,start2,end2,k-(i-start1+1));
        }

    }
};

码后反思

1. 时间复杂度： 每进行一次循环，我们就减少 k / 2 个元素，所以时间复杂度是 $O(log(k))$，而 k = （m + n）/ 2 ，所以最终的复杂也就是 $O（log（m+n））$。
2. 空间复杂度： 虽然我们用到了递归，但是可以看到这个递归属于尾递归，所以编译器不需要不停地堆栈，所以空间复杂度为 O（1）。
3. 记得是除以2.0，这样才会得到浮点数！
4. 注意使用引用类型进行传参，这样速度会快些！
5. 使用递归实现需要明确三个问题：
   • 递归函数的作用是什么？
   • 递归函数的递归边界是什么？
   • 递归函数的递归式是什么？
     其中最重要的就是明确递归函数的作用，一定要能写出递归函数的作用！
6. 这道题目还要特别处理k/2大于len1或者len2的情况；
7. 知道了以后看见log就想二分；
8. 啊，这道题思维量太大了，根本不像简单的二分查找题！

参考文档

1. 题解