leetcode 26: Median of Two Sorted Arrays

Median of Two Sorted Arrays

Total Accepted: 14997 Total Submissions: 88729

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 len = m+n;
        if(len%2==0) {
            return (rec(A, m, B, n, len/2) + rec(A, m, B, n, len/2+1))/2.0;
        } else {
            return rec(A,m,B,n,len/2+1);
        }
    }
    
    double rec(int A[], int m, int B[], int n, int k) {
        if(m<=0) return B[k-1];
        if(m>n) return rec(B,n, A, m, k);
        if(k<=1) return min(A[0], B[0]);
        
        int pa = min(k/2, m);
        int pb = k-pa;
        
        if( A[pa-1]<B[pb-1] ) {
            return rec(A+pa, m-pa, B, n, k-pa);
        } else {
            return rec(A, m, B+pb, n-pb, k-pb);
        }
        
    }
};

first try: uncompleted, do not pass all test cases.

class Solution {
private:
    int len;
    int m;
    int n;
public:
    double findMedianSortedArrays(int A[], int m, int B[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        Solution::m = m;
        Solution::n = n;
        len = m + n;
        
        if(true) {
            return medianRec( A, B,  0, m-1 ) ;
        } else {
            return medianRec( B, A, 0, n-1);
        }
    }
    
    double medianRec( int A[], int B[], int left, int right) {
        if( left > right) 
            return medianRec(B, A, max(0, len/2-m), min(n-1, len/2) ); 
        
        int i = (left+right) / 2;
        int j = len/2 - i - 1;
        
        if (j>=0 && A[i] < B[j]) return medianRec(A, B, i+1, right);
        else if (j<n-1 && A[i] > B[j+1]) return medianRec(A, B, left, i-1);
        else {
            if ( len % 2 == 1 ) return A[i];
            else if (i>0) return (A[i]+max(B[j], A[i-1]))/2.0;
            else return (A[i]+B[j])/2.0;
         }
    }
};