leetcode 第四题 寻找两个有序数组的中位数

寻找两个有序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。
请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
你可以假设 nums1 和 nums2 不会同时为空。
示例 1:
nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0
示例 2:
nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路+代码

先讲解自己的思路，下方提供代码，一份自己手撸，一份网上方法(递归)

思路

采用切割得思想，查找有序数列得中位数
nums1 : 2 4 | 6 8
nums2 : 1 3 5 | 7 9 10
将两组中位数分成 左边一块（left） 右边一块（right）
如果两个数组的长度和为偶数
那么 左边数字个数 == 右边数字个数
如果两个数组的长度和为奇数
那么 一定存在着上面数组长度为奇数或者下面长度为奇数

那么就要满足两个条件

1、左右分块的数字差值小于等于1
2、左边块的最大值 一定小于等于 右边块的最小值

那么问题来了

1、如何分块 ----- 第一次取两个数组长度的中间值，如果是奇数可以让左边或右边多一个，可以用四个变量记录下标
2、如何查找 ----- 以二分法查找，第一次的步长为 最短数组长度的一半，如过不满足第二个条件 就进行偏移，偏移步长为上一次步长的一半，最小为1。
3、如何偏移 ----- 在开始处理时，先将两个数组的长度规定一下，上面为短数组，下面为长数组，当发现左边的最大值产生于短数组时，进行上面(短数组)左偏,下面数组右偏,反之当发现左边的最大值产生于长数组时，进行上面(短数组)右偏,下面数组左偏。
4、何时结束 ----- 满足第二个条件就结束

附上作者代码(未优化)

public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        // 翻转数组 ：使第一个为短数组，第二个为长数组
        if(m > n) { return findMedianSortedArrays(nums2, nums1);}
        // 如果短数组为0，中位数产生于长数组
        if (m==0) {
            if (n%2==0) return ((double) nums2[n/2]+nums2[n/2-1])/2;
            else return (double) nums2[n/2];
        }
        // 参照问题1，记录四个下标
        int leftIdx1 = 0, rightIdx1 = 0;
        int leftIdx2 = 0, rightIdx2 = 0;
        // 记录左边最大值和右边最大值
        int lmax = 0, rmin = 0;
        // 当短数组长度为1时，出现下标越界，拿出单独讨论
        if (m==1) {
        	// 两个数组长度都为1时，直接返回两数和除2
            if (n==1) return ((double) nums1[0]+nums2[0])/2;
            if (n%2==0) {// 如果长数组的长度为偶数
            	// 如果短数组的那个值小于长数组的中间位置的值
                if (nums1[0]<=nums2[n/2]){
                    leftIdx2 = n/2-1;   // 中间左边一个
                    lmax = nums2[leftIdx2]>nums1[0]?nums2[leftIdx2]:nums1[0];
                    return (double) lmax;// 一定是左边最大值
                }
                else {
                    return (double)nums2[n/2]; //一定是nums2[n/2]
                }
            } else {// 如果长数组的长度为奇数
                if (nums1[0]<=nums2[n/2]) {// 如果短数组的那个值小于等于长数组的中间位置的值
                    leftIdx2 = n/2-1;
                    rightIdx2 = n/2;
                    lmax = nums2[leftIdx2]>nums1[0]?nums2[leftIdx2]:nums1[0];
                    rmin = nums2[rightIdx2];
                } else {// 如果短数组的那个值大于长数组的中间位置的值
                    leftIdx2 = n/2;
                    rightIdx2 = (n+1)/2;
                    lmax = nums2[leftIdx2];
                    rmin = nums2[rightIdx2]<nums1[0]?nums2[rightIdx2]:nums1[0];
                }
                return ((double)lmax+rmin)/2;
            }
        }
        //   如果第一个数组长度是是奇数  第一个数组左边多一个数
        //   如果第二个数组长度是是奇数  第一个数组右边多一个数
        leftIdx1 = m%2==0?(m-1)/2:m/2;
        rightIdx1 = m%2==0?m/2:(m+1)/2;
        leftIdx2 = n%2==0?(n-1)/2:n/2-1;
        rightIdx2 = n%2==0?n/2:n/2;
		// 设置步长
        int step = m/2;
        // 核心代码
        // 关键点在于找到左边最大值小于等于右边最小值的位置
        while (true) {
            if (leftIdx1<0) lmax = nums2[leftIdx2];
            if (leftIdx2<0) lmax = nums1[leftIdx1];
            if (rightIdx1>=m) rmin = nums2[rightIdx2];
            if (rightIdx2>=n) rmin = nums1[rightIdx1];
            if(leftIdx1>=0 && leftIdx2>=0) lmax = nums1[leftIdx1]>nums2[leftIdx2]?nums1[leftIdx1]:nums2[leftIdx2];
            if (rightIdx1<m && rightIdx2<n) rmin = nums1[rightIdx1]<nums2[rightIdx2]?nums1[rightIdx1]:nums2[rightIdx2];
            if (lmax <= rmin) { // 在这里结束
                if ((m+n)%2==0) {return ((double) lmax+rmin)/2;}
                else {
                    if (m%2==0) return rmin;
                    else return lmax;
                }
            } else { // 不满足条件就调整步长和下标
                step = step/2==0?1:step/2;
                if (nums1[leftIdx1]>nums2[leftIdx2]) {
                   step = -step;
                }
                leftIdx1 += step;
                rightIdx1 += step;
                leftIdx2 -= step;
                rightIdx2 -= step;
            }
        }
    }

第二段代码来自 leetcode

public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        int left = (m + n + 1) / 2;
        int right = (m + n + 2) / 2;
        return (findKth(nums1, 0, nums2, 0, left) + findKth(nums1, 0, nums2, 0, right)) / 2.0;
    }
    //i: nums1的起始位置 j: nums2的起始位置
    public static int findKth(int[] nums1, int i, int[] nums2, int j, int k){
        if( i >= nums1.length) return nums2[j + k - 1];//nums1为空数组
        if( j >= nums2.length) return nums1[i + k - 1];//nums2为空数组
        if(k == 1){
            return Math.min(nums1[i], nums2[j]);
        }
        int midVal1 = (i + k / 2 - 1 < nums1.length) ? nums1[i + k / 2 - 1] : Integer.MAX_VALUE;
        int midVal2 = (j + k / 2 - 1 < nums2.length) ? nums2[j + k / 2 - 1] : Integer.MAX_VALUE;
        if(midVal1 < midVal2){
            return findKth(nums1, i + k / 2, nums2, j , k - k / 2);
        }else{
            return findKth(nums1, i, nums2, j + k / 2 , k - k / 2);
        }
    }

原创文章，转载标注
希望各路朋友评论区指正，优化代码