【LeetCode之路】4. 两个有序数组的中位数

一、题目

二、解法

1.思路：

由中位数的特点入手：将一个数组分为元素数量相等的left和right两个数组并且max(left)<=min(right)。

这里输入是两个数组，设为A和B, 大小为m和n。 假设中位数为x，且x将A和B分别在下标 i 和 j 处划分，得到：

             left                       |             right

A[0], A[1], A[2] ... A[i-1]    |    A[i], A[i+1] ... A[m] 

B[0], B[1], B[2] ... B[j-1]    |    B[j], B[j+1] ... B[n]

可以得到如下关系：

（1）数量相等：i+j=m+n-(i+j) 。当 i 确定时，j = (m+n)/2 - i.

  (2)  max(left)<=min(right): A[i-1]<=B[j] 并且 B[j-1]<=A[i]

上面情况一定存在吗？一定，因为中位数肯定存在。

注意到：当 i 确定时，j 也就随之确定（根据关系1）。那问题就变成寻找位置i，使 i，j 满足关系2.

为了使 i 的初始范围减小，不妨另m<=n;

如果从i=0（A中元素全部在right中）开始到 i = m+1（A中元素全部在left中）,递增检查，则复杂度为Ω(m)。

题目要求复杂度为Ω(log(m+n)), 显然这里应该用二分查找。二分查找的关键在对一个中值，判断结果必须使其查找范围落入左右两部分之一。

现在我们考虑任意划分位置 i 。

它只有如下三种情况：

（a）A[i-1] > B[j]，这时，应该增大 i ，j 会相应减小。

（b）B[j-1]>A[i], 这时，应该减小 i ，j也会相应增大。

（c）A[i-1]<=B[j] 并且 B[j-1]<=A[i]，满足划分条件，此时可返回中位数。

可以把增大 i 的值形象地看成向右推动A，为了保证left与right的数量相等，B必须向左推动同样数量的元素。这样导致更新的A[i-1]增大，B[j]减小，进而往满足A[i-1] <=B[j]的方向走。同理，减小 i 为将A向左推，B向右。

当（a）(b)情况都不满足时，即（c）中条件成立。此时可以找出中位数。如果元素总量为奇数，中位数为min(right) , 当元素总数为偶数时，中位数为 (max(left)+min(right))/2.0 。

2.实现：

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if(nums1.length>nums2.length){//保证nums1是最短的数组
            int[] temp=nums1;
            nums1=nums2;
            nums2=temp;
        }
        int m=nums1.length, n=nums2.length;
        int min=0,max=m;
        int leftMax=0, rightMin=0;
        int i,j;
        while(true){     //二分查找i的位置
            i=(max+min)/2;
            j=(m+n)/2-i;
            if((i-1>=0&&nums1[i-1]>nums2[j]))       //nums1往右推
                max=i;
            else if(i<m&&nums2[j-1]>nums1[i])       //nums1往左推
                min=i+1;
            else{                                 //nums1位置正确
                //算出left最大值与right最小值
                if(i>0&&j>0)
                    leftMax=Math.max(nums1[i-1],nums2[j-1]);
                else if(i==0&&j>0)   //j>0避免出现nums1为空，nums2只有一个元素的情况。此时leftMax不存在
                    leftMax=nums2[j-1];
                else if(j==0&&i>0)
                    leftMax=nums1[i-1];
                if(i<m&&j<n)
                    rightMin=Math.min(nums1[i],nums2[j]);
                else if(i==m)
                    rightMin=nums2[j];
                else 
                    rightMin=nums1[i];
                if((m+n)%2==1)
                    return rightMin;
                return (leftMax+rightMin)/2.0;
            }
        } 
    }
}

3.分析：

时间复杂度：Ω(log(min(m,n)))。

空间复杂度：θ(1).

4.测试结果：