LeetCode Top 100 Liked Questions 4.Median of Two Sorted Arrays(Java版； Hard)

welcome to my blog

LeetCode Top 100 Liked Questions 4.Median of Two Sorted Arrays(Java版; Hard)

题目描述

There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

You may assume nums1 and nums2 cannot be both empty.

Example 1:

nums1 = [1, 3]
nums2 = [2]

The median is 2.0
Example 2:

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

(1)在两个排序数组中找到第k小的数

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n = nums1.length, m = nums2.length;
        int count = n + m;
        if((count&1)==1){
            return core(nums1, nums2, 0, 0, count/2+1);
        }else{
            return (core(nums1, nums2, 0, 0, count/2) + core(nums1, nums2, 0, 0, count/2+1))/2.0;
        }
    }

    private double core(int[] nums1, int[] nums2, int i, int j, int k){
        //base case
        int n = nums1.length, m = nums2.length;
        if(i>=n){
            return nums2[j+k-1];
        }else if(j>=m){
            return nums1[i+k-1];
        }
        if(k==1){
            return Math.min(nums1[i], nums2[j]);
        }
        //第k/2个数的索引
        int mid1 = i + k/2 - 1;
        int mid2 = j + k/2 - 1;
        int a = mid1 >= n ? Integer.MAX_VALUE : nums1[mid1];
        int b = mid2 >= m ? Integer.MAX_VALUE : nums2[mid2];
        if(a<b){
            return core(nums1, nums2, mid1+1, j, k-k/2);
        }else{
            return core(nums1, nums2, i, mid2+1, k-k/2);
        }

    }
}

第一次做,看了题解才会的, 对切割位置进行二分; m个元素有m+1个切割位置, 切割位置取值为0,1,2,…,m, 当切割位置为i时表示左边有i个元素, 同时i作为索引时指向切割后右边的第一个元素; 是对短数组的切割位置进行二分, 不是长数组; 规定, 元素总数为偶数时, 左一左二的元素数量等于右一右二; 元素总数为奇数时, 左一左二的元素数量比右一右二多一个; while循环中的越界检查也非常重要

设arr1长度为m, arr2长度为n, m+n是奇数
将arr1分成两部分, 将arr2分成两部分, arr1的两部分对应左一和右一, arr2的两部分对应左二和右二
如果左一<=右二, 同时左二<=右一, 那么左一左二的元素都小于右一右二的元素，此时如果左一左二的元素个数相加等于(m+n+1)/2, 由于m+n是奇数, 所以中间的元素是第(m+n+1)/2个, 那么中位数就等于左一左二中的最大值

如果左一的最大值大于右二的最小值, 说明左一中的元素过多, 需要减少(分割线左移:这个操作涉及二分), 与此同时, 由于左一和左二的元素个数和为(m+n+1)/2, 所以左二中的元素个数增加

如果左二的最大值大于右一的最小值, 说明左二中的元素过多, 需要减少(分割线左移:这个操作涉及二分), 与此同时, 由于左一和左二的元素个数和为(m+n+1)/2, 所以左一中的元素个数增加

如果左一是整个arr1时, 此时没有右一, 中位数是左一左二的最大值
如果右一是整个arr1时, 此时没有左一, 中位数是左二的最大值
如果左二是整个arr2时, 此时没有右二, 中位数左一左二的最大值
如果右二是整个arr2时, 此时没有左二, 中位数是左一的最大值

=======================================================================================================
=======================================================================================================

设arr1长度为m, arr2长度为n, m+n是偶数
将arr1分成两部分, 将arr2分成两部分, arr1的两部分对应左一和右一, arr2的两部分对应左二和右二
如果左一<=右二, 同时左二<=右一, 那么左一左二的元素都小于右一右二的元素, 此时如果左一左二的元素个数相加等于(m+n)/2, 由于m+n是偶数, 所以中间的元素有两个, 分别是第(m+n)/2个和第(m+n)/2+1个, 分别对应左一左二中的最大值和右一右二中的最小值

如果左一的最大值大于右二的最小值, 说明左一中的元素过多, 需要减少(分割线左移:这个过程涉及二分), 与此同时, 由于左一和左二的元素个数和为(m+n)/2, 所以左二中的元素个数增加

如果左二的最大值大于右一的最小值, 说明左二中的元素过多, 需要减少(分割线左移:这个过程涉及二分), 与此同时, 由于左一和左二的元素个数和为(m+n)/2, 所以左一中的元素个数增加

如果左一是整个arr1时, 此时没有右一, 中位数是左一左二最大值和右二最小值的平均值
如果右一是整个arr1时, 此时没有左一, 中位数是左二最大值和右一右二最小值的平均值
如果左二是整个arr2时, 此时没有右二, 中位数是左一左二最大值和右二最小值的平均值
如果右二是整个arr2时, 此时没有右一, 中位数是左一最大值和左二右二最小值的平均值

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if(nums1==null)
            return nums2.length%2==1 ? nums2[nums2.length/2]*1.0 : (nums2[nums2.length/2-1]+nums2[nums2.length/2])/2.0;
        if(nums2==null)
            return nums1.length%2==1 ? nums1[nums1.length/2]*1.0 : (nums1[nums1.length/2-1] + nums1[nums1.length/2])/2.0;
        int m = nums1.length, n = nums2.length;
        //让nums1作为短的数组, 后面对短的数组进行二分
        if(m>n){
            int[] temp = nums1; nums1 = nums2; nums2 = temp;
            int tmp = m; m = n; n = tmp;
        }
        //右一最小值索引
        int i;
        //右二最小值索引
        int j;
        //left和right表示切割的位置, 0表示切割后左边有0个元素, 1表示切割后左边有1个元素
        int left = 0, right = m;
        //循环条件
        while(left <= right){
            //对短数组的切割边界进行二分
            i = (left + right )/2; //i作为切割线表示左边有i个元素, 作为索引指向切割后右边第一个元素
            //令j也指向右边第一个, 那么左一左二的元素个数为i+j满足 i+j = (m+n)/2
            j = (m+n+1)/2 - i; //m+n是偶数时, 左一左二的元素个数和右一右二相等; m+n是奇数时, 左一左二比右一右二多一个

            //左一大于右二, 将nums1分割线右边界左移,缩小左一范围
            //要保证左一有元素, 所以i>left
            if(i > left && nums1[i-1] > nums2[j])
                right = i - 1;
            //左二大于右一, 将nums1分割线左边界右移,扩大左一范围, 从而缩小左二范围
            //要保证右一有元素, 所以i<right
            else if(i < right && nums2[j-1] > nums1[i])
                left = i + 1;
                //左一<=右二 && 左二<=右一
            else{
                int leftMax;
                //右一是整个nums1
                if(i==0)
                    leftMax = nums2[j-1];
                //右二是整个nums2
                else if(j==0)
                    leftMax = nums1[i-1];
                else
                    leftMax = Math.max(nums1[i-1], nums2[j-1]);
                if((m+n)%2==1)
                    return leftMax;

                int rightMin;
                //左一是整个nums1
                if(i==m)
                    rightMin = nums2[j];
                //左二是整个nums2
                else if(j==n)
                    rightMin = nums1[i];
                else
                    rightMin = Math.min(nums1[i], nums2[j]);
                return (leftMax+rightMin)/2.0;
            }
        }
        return 0.0;
    }
}

第一次做, 模拟归并过程, 但并不创建辅助数组, 只需要记录两个位置的元素, 一个是len/2-1, 另一个是len/2; while循环到len/2-1即可, 我最开始循环到len/2处, 这样每次循环需要保存上一次循环的数, 容易写错. 循环到len/2-1处,之后再单独寻找len/2处的元素就方便多了; 不过不满足时间复杂度O(logm+n)的要求, 得用二分法

/*
将两个有序数组归并到中点处, 模拟归并过程, 不需要真正的进行归并
*/
class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if(nums1==null)
            return nums2.length%2==1 ? nums2[nums2.length/2]*1.0 : (nums2[nums2.length/2-1]+nums2[nums2.length/2])/2.0;
        if(nums2==null)
            return nums1.length%2==1 ? nums1[nums1.length/2]*1.0 : (nums1[nums1.length/2-1]+nums1[nums1.length/2])/2.0;
        int len = nums1.length + nums2.length;
        int p1 =0, p2=0, i=0;
        int curr = 0;
        //循环到len/2-1处
        while(p1<nums1.length && p2<nums2.length && i<len/2){
            if(nums1[p1] <= nums2[p2]){
                curr = nums1[p1]; 
                p1++;
            }
            else{
                curr = nums2[p2];
                p2++;
            }
            i++;
        }
        while(p1<nums1.length && i<len/2){
            curr = nums1[p1];
            p1++;
            i++;
        }
        while(p2<nums2.length && i<len/2){
            curr = nums2[p2];
            p2++;
            i++;
        }
        
        int next=0;
        if(p1==nums1.length)
            next = nums2[p2];
        else if(p2==nums2.length)
            next = nums1[p1];
        else
            next = Math.min(nums1[p1], nums2[p2]);
        
        return len%2==1 ? next*1.0 : (curr + next)/2.0;
    }
}

题解

class Solution {
    public double findMedianSortedArrays(int[] A, int[] B) {
        int m = A.length;
        int n = B.length;
        if (m > n) { // to ensure m<=n
            int[] temp = A; A = B; B = temp;
            int tmp = m; m = n; n = tmp;
        }
        int iMin = 0, iMax = m, halfLen = (m + n + 1) / 2;
        while (iMin <= iMax) {
            int i = (iMin + iMax) / 2;
            int j = halfLen - i;
            if (i < iMax && B[j-1] > A[i]){
                iMin = i + 1; // i is too small
            }
            else if (i > iMin && A[i-1] > B[j]) {
                iMax = i - 1; // i is too big
            }
            else { // i is perfect
                int maxLeft = 0;
                if (i == 0) { maxLeft = B[j-1]; }
                else if (j == 0) { maxLeft = A[i-1]; }
                else { maxLeft = Math.max(A[i-1], B[j-1]); }
                if ( (m + n) % 2 == 1 ) { return maxLeft; }

                int minRight = 0;
                if (i == m) { minRight = B[j]; }
                else if (j == n) { minRight = A[i]; }
                else { minRight = Math.min(B[j], A[i]); }

                return (maxLeft + minRight) / 2.0;
            }
        }
        return 0.0;
    }
}