了解两个排序数组中位数的算法

Question

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)).

I don't understand the formulas for calculating aMid, and bMid. What's the logic behind these formulas?

int aMid = aLen * k / (aLen + bLen); // a's middle count

int bMid = k - aMid - 1; // b's middle count

Here is the link to program. http://www.programcreek.com/2012/12/leetcode-median-of-two-sorted-arrays-java/][1]

public static double findMedianSortedArrays(int A[], int B[]) {
    int m = A.length;
    int n = B.length;

    if ((m + n) % 2 != 0) // odd
        return (double) findKth(A, B, (m + n) / 2, 0, m - 1, 0, n - 1);
    else { // even
        return (findKth(A, B, (m + n) / 2, 0, m - 1, 0, n - 1) 
            + findKth(A, B, (m + n) / 2 - 1, 0, m - 1, 0, n - 1)) * 0.5;
    }
}

public static int findKth(int A[], int B[], int k, 
    int aStart, int aEnd, int bStart, int bEnd) {

    int aLen = aEnd - aStart + 1;
    int bLen = bEnd - bStart + 1;

    // Handle special cases
    if (aLen == 0)
        return B[bStart + k];
    if (bLen == 0)
        return A[aStart + k];
    if (k == 0)
        return A[aStart] < B[bStart] ? A[aStart] : B[bStart];

    int aMid = aLen * k / (aLen + bLen); // a's middle count    
                                      // I AM STUCK HERE

    int bMid = k - aMid - 1; // b's middle count

    // make aMid and bMid to be array index
    aMid = aMid + aStart;
    bMid = bMid + bStart;

    if (A[aMid] > B[bMid]) {
        k = k - (bMid - bStart + 1);
        aEnd = aMid;
        bStart = bMid + 1;
    } else {
        k = k - (aMid - aStart + 1);
        bEnd = bMid;
        aStart = aMid + 1;
    }

    return findKth(A, B, k, aStart, aEnd, bStart, bEnd);
}

I got some idea, from the comments with the code, how these formulas are calculated but still don't understand to explain to someone "why these formulas" Or what's the logic behind these formulas?

For int aMid = aLen * k / (aLen + bLen); // a's middle count As aMid = aLen / 2 --(i)

and k = （aLen + bLen)/2, -->2 = (aLen + bLen)/k

putting value of 2 in equ (i)

so aMid = aLen/(aLen + bLen)/k== aLen *k/ (aLen+bLen)

and for int bMid = k - aMid - 1; // b's middle count

aMid + bMid + 1 = k must be satisfied to be able to make the conclusions it does when A[aMid] > B[bMid]

As for why aMid + bMid + 1 = k is significant: If A[aMid] is greater than B[bMid], you know that any elements in after A[aMid] in A can't be the kth element since there are too many elements in B lower than it (and would exceed k elements). You also know that B[bMid] and any element before B[bMid] in B can't be the kth element since there are too few elements in A lower than it (there wouldn't be enough elements before B[bMid] to be the kth element).

Answer 1

As you already mentioned: aMid + bMid + 1 = k must be satisfied to be able to make the conclusions that:
when A[aMid] > B[bMid] we can throw away everything before bMid and everything after (including) aMid ,
because we know that there are bMid + aMid + 1 (from including aMid ) = k elements smaller than A[aMid] . Therefor our median lies in the remaining arrays.

With this in mind it does not really matter how we set up our two mid values aMid and bMid in the first place. The only thing to take care of is not letting one of them cause an IndexOutOfBoundsException .

int aMid = 0;
int bMid = k - aMid - 1;
if(bMid >= bLen) {
    bMid = bLen - 1;
    aMid = k - bMid - 1;
}

Would do the trick as well. But it would take more than O(log(n+m)) time because in the worst case we only always skip one element ( A[0] ).
What we want is to always throw away a percentage of aLen + bLen .
In our case this is:

A > B: k = k - (bMid +1) = k - (k - aMid) = aMid = k * (aLen / (aLen + bLen))
B > A: k = k - (aMid + 1) = k - (k * aLen / (aLen + bLen)) -1 = k * (bLen / (aLen + bLen)) - 1

Ignoring the -1 and assuming that the probability for A > B is the same as B > A we get:
E(k) = 0.5 * k * (aLen/(aLen + bLen)) + 0.5 * k * (bLen/(aLen + bLen))
= 0.5 * k (aLen + bLen)/(aLen + bLen) = 0.5 * k
Meaning that we get approximately O(log(n + m)) recursive calls until k is 0 and then the functions stops.