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

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

给定两个大小分别为 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

示例 3：

输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000

示例 4：

输入：nums1 = [], nums2 = [1]
输出：1.00000

示例 5：

输入：nums1 = [2], nums2 = []
输出：2.00000

提示：

nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays

解法一：常规排序

/**
打擂台的方法，从小到大将两个数组合并到nums3中，但是因为我们只需要中位数，所以不用完全合并，只需要合并sumLength/2+1个就可以，如果sumLength为奇数，中位数就是nums3[sumLength/2]；如果sumLength为偶数，中位数就是( t = (double)nums3[sumLength/2-1]+nums3[sumLength/2]) > 0 ? t/2 : 0)，之所以判断和大于0，是因为防止nums1 = [0,0],nums2 = [0,0]的情况会出现0/2的情况。
*/
class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int sumLength = nums1.length + nums2.length;
        int[] nums3 = new int[sumLength/2+1];
        double t = 0;
        if (sumLength == 0){
            return 0;
        }else if(nums1.length == 0){
            return nums2.length % 2 ==0 ? ((t = (double)nums2[nums2.length/2-1]+nums2[nums2.length/2]) > 0 ? t/2 : 0) : ((double)nums2[nums2.length/2]);
        }else if(nums2.length == 0){
            return nums1.length % 2 ==0 ? ((t = (double)nums1[nums1.length/2-1]+nums1[nums1.length/2]) > 0 ? t/2 : 0) : ((double)nums1[nums1.length/2]);
        }
        int k = 0;
        int j = 0;
        for(int i=0;i<sumLength/2+1;i++){
            if(k>=nums1.length){
                nums3[i] = nums2[j++];
            }else if(j>=nums2.length){
                nums3[i] = nums1[k++];
            }else{
                nums3[i] = nums1[k] < nums2[j] ? nums1[k++] : nums2[j++];
            }
        }
        return sumLength%2 ==0 ? (( t = (double)nums3[sumLength/2-1]+nums3[sumLength/2]) > 0 ? t/2 : 0) : ((double)nums3[sumLength/2]);
    }
}

执行效果

解法二：二分法

解题思路

上边的思路，时间复杂度都达不到题目的要求 O(log(m+n)）。看到 log，很明显，我们只有用到二分的方法才能达到。我们不妨用另一种思路，题目是求中位数，其实就是求第 k 小的数的一种特殊情况，而求第 k 小的数有一种算法。

由于数列是有序的，其实我们完全可以一半儿一半儿的排除。假设我们要找第 k 小数，我们可以每次循环排除掉 k/2 个数。看下边一个例子。

假设我们要找第 7 小的数字。

我们比较两个数组的第 k/2 个数字，如果 k 是奇数，向下取整。也就是比较第 33 个数字，上边数组中的 44 和下边数组中的 33，如果哪个小，就表明该数组的前 k/2 个数字都不是第 k 小数字，所以可以排除。也就是 11，22，33 这三个数字不可能是第 77 小的数字，我们可以把它排除掉。将 13491349 和 4567891045678910 两个数组作为新的数组进行比较。

更一般的情况 A[1] ，A[2] ，A[3]，A[k/2] … ，B[1]，B[2]，B[3]，B[k/2] … ，如果 A[k/2]<B[k/2] ，那么A[1]，A[2]，A[3]，A[k/2]都不可能是第 k 小的数字。

A 数组中比 A[k/2] 小的数有 k/2-1 个，B 数组中，B[k/2] 比 A[k/2] 小，假设 B[k/2] 前边的数字都比 A[k/2] 小，也只有 k/2-1 个，所以比 A[k/2] 小的数字最多有 k/1-1+k/2-1=k-2个，所以 A[k/2] 最多是第 k-1 小的数。而比 A[k/2] 小的数更不可能是第 k 小的数了，所以可以把它们排除。

橙色的部分表示已经去掉的数字。

由于我们已经排除掉了 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，我们此时将箭头指向它的末尾就可以了。这样的话，由于 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 sumLength = nums1.length + nums2.length;
        if (sumLength == 0){
            return 0;
        }
        int k = (sumLength+1)/2;
        int n = (sumLength+2)/2;
        return ((double)method(nums1,0,nums2,0,k)+method(nums1,0,nums2,0,n))/2;
    }
    public int method(int[] nums1,int aStart, int[] nums2,int bStart,int k){
        int len1 = nums1.length-aStart;
        int len2 = nums2.length-bStart;
        if(len1==0){
            return nums2[bStart+k-1];
        }
        if(len2==0){
            return nums1[aStart+k-1];
        }
        if(k==1){
            return Math.min(nums1[aStart],nums2[bStart]);
        }
        int i = aStart + Math.min(len1,k/2)-1;
        int j = bStart + Math.min(len2,k/2)-1;
        if(nums1[i]<nums2[j]){
            return method(nums1,i+1,nums2,bStart,k-(i-aStart+1));
        }else{
            return method(nums1,aStart,nums2,j+1,k-(j-bStart+1));
        }
    }
}

执行效率

将递归优化为循环

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int sumLength = nums1.length + nums2.length;
        if (sumLength == 0){
            return 0;
        }
        int k = (sumLength+1)/2;
        int aStart = 0;
        int bStart = 0;
        int len1 =0;
        int len2 = 0;
        int i = 0;
        int j = 0;
        int left = -1;
        int right = -1;
        boolean flag = true;
        while(true){
            len1 = nums1.length-aStart;
            len2 = nums2.length - bStart;
            
            if(len1==0){
                if(sumLength%2!=0){
                    return nums2[bStart+k-1];
                }else{
                    if(!flag){
                        right = nums2[bStart+k-1];
                        break;
                    }
                    return ((double)nums2[bStart+k-1]+nums2[bStart+k])/2;
                }
            }
            if(len2==0){
                if(sumLength%2!=0){
                    return nums1[aStart+k-1];
                }else{
                    if(!flag){
                        right = nums1[aStart+k-1];
                        break;
                    }
                    return ((double)nums1[aStart+k-1]+nums1[aStart+k])/2;
                }
            }
            if(k==1){
                if(sumLength%2!=0){
                    return Math.min(nums1[aStart],nums2[bStart]);
                }else{
                    if(flag){
                        left = Math.min(nums1[aStart],nums2[bStart]);
                        flag = false;
                        k++;
                    }else{
                        right = Math.min(nums1[aStart],nums2[bStart]);
                        break;
                    }
                }
            }
            i = aStart+Math.min(len1,k/2)-1;
            j = bStart+Math.min(len2,k/2)-1;

            if(nums1[i]<nums2[j]){
                k = k-(i-aStart+1);
                aStart = i+1;
            }else{
                k = k - (j-bStart+1);
                bStart = j+1;
            }
        }
        return ((double)left+right)/2;
        
    }
}

执行效率