【leetcode】Median of Two Sorted Arrays

Median of Two Sorted Arrays

There are two sorted arrays A and B 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)).

 

 

 

 

最简单的，把两个数组组合到一起，然后排序，找到中位数，不过不符合复杂度要求

 

class Solution {
public:
    double findMedianSortedArrays(int A[], int m, int B[], int n) {
       
        int i,j;
        vector<int> arr(m+n);
       
        for(i=0;i<m;i++)
            arr[i]=A[i];
       
        for(j=0;j<n;j++)
            arr[m+j]=B[j];
       
        sort(arr.begin(),arr.end());
       
        if((m+n)%2==0)
            return (arr[(m+n)/2]+arr[(m+n)/2-1])/2.0;
        else
            return arr[(m+n)/2];
    }
};

 

 

 

解法二，不进行排序，直接在合并数组时确定顺序，不符合复杂度要求：

 

class Solution {
public:
    double findMedianSortedArrays(int A[], int m, int B[], int n) {
       
        int i,j,k;
        i=j=k=0;
       
        vector<int> arr(m+n);
        while(i<m||j<n)
        {
            int tmp;
            if(i>=m)
            {
                tmp=B[j];
                j++;
            }
            else if(j>=n)
            {
                tmp=A[i];
                i++;
            }
            else if(A[i]<B[j])
            {
                tmp=A[i];
                i++;
            }
            else
            {
                tmp=B[j];
                j++;
            }
            arr[k]=tmp;
            k++;
        }
       
        if((m+n)%2==0)
            return (arr[(m+n)/2]+arr[(m+n)/2-1])/2.0;
        else
            return arr[(m+n)/2];
    }
};

 

 

 

解法三，通过在两个排列好的数列中寻找第K小的元素来寻找中位数

 

第1小，代表了最小的数   

 

 

首先假设数组A和B的元素个数都大于k/2，我们比较A[k/2-1]和B[k/2-1]两个元素，这两个元素分别表示A的第k/2小的元素和B的第k/2小的元素。这两个元素比较共有三种情况：>、<和=。如果A[k/2-1]<B[k/2-1]，这表示A[0]到A[k/2-1]的元素都在A和B合并之后的前k小的元素中。换句话说，A[k/2-1]不可能大于两数组合并之后的第k小值，所以我们可以将其抛弃。

当A[k/2-1]>B[k/2-1]时存在类似的结论。

当A[k/2-1]=B[k/2-1]时，我们已经找到了第k小的数，也即这个相等的元素

 

class Solution {
public:
 
 int findKth(int A[],int m,int B[],int n,int k)
    {
          //为了后续计算方便，使得B的长度始终大于B的长度
        if(m>n)
        {
            return findKth(B,n,A,m,k);
        }
       
        //如果第一个数组为空了，则返回第k小的数
        if(m==0)
        {
            return B[k-1];
        }
       
        //如果寻找第一小的数
        if(k==1)
        {
            return min(A[0],B[0]);
        }
       
        //第k/2个元素，或者是最后一个元素
        int pa=min(m-1,k/2-1);
        //保证A,B共取了k个元素
        int pb=(k-(pa+1))-1;
       
        
        if(A[pa]<B[pb])
        {
            //当排除了pa+1个元素后，则我们下一次寻找的就是k-(pa+1)大的元素了
            return findKth(A+(pa+1),m-(pa+1),B,n,k-(pa+1));
        }
        else if(A[pa]>B[pb])
        {
            return findKth(A,m,B+(pb+1),n-(pb+1),k-(pb+1));
        }
        else if(A[pa]==B[pb])
        {
            return A[pa];
        }
    }
 
    double findMedianSortedArrays(int A[], int m, int B[], int n) {
       
        if((m+n)%2==0)
            return (findKth(A,m,B,n,(m+n)/2)+findKth(A,m,B,n,(m+n)/2+1))/2.0;
        else
            return findKth(A,m,B,n,(m+n)/2+1);
    }
};