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

4.寻找两个正序数组的中位数

题目描述

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

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

思路

复杂度要求为O(log (m+n)) 。如果m+n为奇数，寻找第（m+n)/2+1大的数，如果为偶数，寻找第（m+n）/2和（m+n)/2+1大的数，构造一个函数，寻找两个有序数组中第k大的数

代码（参考的题解）

解法1

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int m = nums2.length;
        //因为数组是从索引0开始的，因此我们在这里必须+1，即索引(k+1)的数，才是第k个数。
        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;
    }
    private int getKth(int[] nums1, int start1, int end1, int[] nums2, int start2, int end2, int k) {
        //因为索引和算数不同6-0=6，但是是有7个数的，因为end初始就是数组长度-1构成的。
        //最后len代表当前数组(也可能是经过递归排除后的数组)，符合当前条件的元素的个数
        int len1 = end1 - start1 + 1;
        int len2 = end2 - start2 + 1;
        //让 len1 的长度小于 len2，这样就能保证如果有数组空了，一定是 len1
        //就是如果len1长度小于len2，把getKth()中参数互换位置，即原来的len2就变成了len1，即len1，永远比len2小
        if (len1 > len2) return getKth(nums2, start2, end2, nums1, start1, end1, k);
        //如果一个数组中没有了元素，那么即从剩余数组nums2的其实start2开始加k再-1.
        //因为k代表个数，而不是索引，那么从nums2后再找k个数，那个就是start2 + k-1索引处就行了。因为还包含nums2[start2]也是一个数。因为它在上次迭代时并没有被排除
        if (len1 == 0) return nums2[start2 + k - 1];

        //如果k=1，表明最接近中位数了，即两个数组中start索引处，谁的值小，中位数就是谁(start索引之前表示经过迭代已经被排出的不合格的元素，即数组没被抛弃的逻辑上的范围是nums[start]--->nums[end])。
        if (k == 1) return Math.min(nums1[start1], nums2[start2]);

        //为了防止数组长度小于 k/2,每次比较都会从当前数组所生长度和k/2作比较，取其中的小的(如果取大的，数组就会越界)
        //然后素组如果len1小于k / 2，表示数组经过下一次遍历就会到末尾，然后后面就会在那个剩余的数组中寻找中位数
        int i = start1 + Math.min(len1, k / 2) - 1;
        int j = start2 + Math.min(len2, k / 2) - 1;

        //如果nums1[i] > nums2[j]，表示nums2数组中包含j索引，之前的元素，逻辑上全部淘汰，即下次从J+1开始。
        //而k则变为k - (j - start2 + 1)，即减去逻辑上排出的元素的个数(要加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));
        }
    }

解法2

class Solution {
    public double findMedianSortedArrays(int[] A, int[] B) {
        int m = A.length;
        int n = B.length;
       //如果A的长度大于B,则调换位置,再次调用方法,保证m <= n,目的是后续可以实现只移动i来实现分割两个数组,如果A数组大于B数组那么B数组就很容易发生数组下标越界异常.
        if(m > n ){
            return findMedianSortedArrays(B,A);
        }
        //这两个值用来进行二分查找
        int iMin = 0;
        int iMax = m;

        while(iMin <= iMax){
            //变量i用于分割A数组
            int i = (iMin + iMax)/2;

            //变量j用于分割B数组
            //这里+1是为了统一奇数和偶数,让j始终与偶数结果一致
            //减去i是为了在i变动的同时,j相应变动
            int j = (m + n +1)/2 - i;

            //因为分割的话,选择的是i和j的左边,也就是说比如 A = 12345  B = 234567 ,这个时候j的前一位是5,被分割到了左边部分,i位是3在右边部分,这个时候i需要增大.
            if( j > 0 && i < m  && A[i] < B[j - 1] ){     
                //将iMin移动到i的下一位实现二分,同时j往前移动      
                iMin = i + 1;
            }
            //这个时候i需要减小 
            else if( i > 0 && j < n && A[i - 1] > B[j]){
                iMax = i - 1;
            }
            //当以上if语句都没走时,这个时候已经满足条件了,但是还需要进行边界的一些特别判断
            else{

                //这个变量用来记录,达到条件后,边界情况下,左边部分的最大值
                int maxLift = 0;

                //当i等于0时,说明j的左边就是全部的左边部分,那么取j - 1 就是左边部分的最大值
                if(i == 0){
                    maxLift = B[j - 1];
                }
                //如果j等于0,说明i的左边就是全部的左边部分,那么取 i -1 就是左边部分的最大值
                else if(j == 0){
                    maxLift = A[i - 1];
                }
                //如果都不为0,那么就是正常情况,判断一下i - 1 和 j - 1 位 那个大就取那个
                else{
                    maxLift = Math.max(A[i - 1],B[j - 1]);
                }



                //注意这里如果m + n的长度为奇数,那么则不需要判断右边的部分,左边部分多出来的那个最大值就是中位数.
                if((m + n)%2 != 0){
                    return maxLift;
                }


                
                //这个变量用来记录,右边部分的最小值
                int minLisft = 0;

                //当i等于m的时候,说明j的右边就是全部的右边部分取j
                //注意,因为分割是从 j  - 1 到j 之间分割的 也就是说这个时候取j 就是右边最小值
                if(i == m){
                    minLisft = B[j];
                }
                //同理
                else if(j == n){
                    minLisft = A[i];
                }
                //正常情况
                else{
                    minLisft = Math.min(A[i],B[j]);
                }
                
                //当 m + n为偶数的时候,这个时候中位数就是(左边最大值+右边最小值)/2
                return (maxLift + minLisft)/2.0;
            }
        }
        //这个表示两个数组长度为0时,直接返回0;
        return 0.0;
    }
}