寻找两个正序数组的中位数（困难）

题目

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

思路

1、可以说面试的时候第一时间想到的方法就是暴力破解的方法了（但是不符合时间复杂度的要求，但是代码也一样放出来）即先将两个数组合并，两个有序数组的合并也是归并排序中的一部分。然后根据奇数，还是偶数，返回中位数。

2、看到 log，很明显，我们只有用到二分的方法才能达到。我们不妨用另一种思路，题目是求中位数，其实就是求第 k 小数的一种特殊情况，而求第 k 小数有一种算法。

假设我们要找第 k 小数，我们可以每次循环排除掉 k/2 个数。看下边一个例子

我们比较两个数组的第 k/2 个数字，如果 k 是奇数，向下取整，也就是取第3个数，上边数组中的 4 和下边数组中的 3，如果哪个小，就表明该数组的前 k/2 个数字都不是第 k 小数字（因为比较小的那个数的前面都是比这个数小的，因为题目给的是正序数组），所以可以排除。也就是 1，2，3 这三个数字不可能是第 7 小的数字，我们可以把它排除掉。将 1349 和 45678910 两个数组作为新的数组进行比较。

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

接着又排除掉 2 个数字，所以现在找k= 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，我们此时将箭头指向它的末尾就可以了。这样的话，由于 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(int[] nums1, int[] nums2) {
        int m = nums1.length,n=nums2.length;
        int[] nums = new int[m+n];

        if(m==0) { // 当数组1是空数组时
            if (n%2==0) { // 当数组2的长度是偶数
                return (nums2[n/2-1]+nums2[n/2]) / 2.0; // 仅返回数组2的中位数即可
            } else { // 当数组2的长度是奇数
                return nums2[n/2];
            }
        }
        if(n==0) { // 当数组2是空数组时
            if (m%2==0) { // 当数组1的长度是偶数
                return (nums1[n/2-1]+nums1[n/2]) / 2.0; // 仅返回数组1的中位数即可
            } else { // 当数组1的长度是奇数
                return nums1[n/2];
            }
        }

        // 当数组1和数组2都不是空数组时
        int i=0,j=0,count=0;
        while(count!=(m+n)) {
            if(i==m) { // 当数组1中所有数已经全部被放入新数组中时
                while (j!=n) {
                    nums[count++] = nums2[j++];
                }
                break;
            }

            if(j==n) {// 当数组2中所有数已经全部被放入新数组中时
                while (i!=m) {
                    nums[count++] = nums1[i++];
                }
                break;
            }
            if(nums1[i]<nums2[j]) {
                nums[count++] = nums1[i++];
            } else {
                nums[count++] = nums2[j++];
            }
        }

        if(count%2==0) {
            return (nums[count/2-1] + nums[count/2]) /2.0;
        } else {
            return nums[count/2];
        }
    }
}

class Solution {
public double findMedianSortedArrays(int[] nums1, int[] nums2) {// 寻找第k小的数（满足时间复杂度要求）
    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;  
}
    //start（数组的首元素索引），end（数组的元素索引）
    private int getKth(int[] nums1, int start1, int end1, int[] nums2, int start2, int end2, int k) {
        int len1 = end1 - start1 + 1; //比如索引 0 5 实际长度是 5-0+1=6
        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; // 防止数组长度小于k/2
        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));
        }
    }


}