[leetcode]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)).

1. 第一次看到此题时，我的想法是现在A中折半查找缩小范围，比如取得A的中间数A[i]，然后在B中找到A[i]，然后便可以缩小范围。A中没有再找B。这个与最后的推荐做法有些类似。
2. 错误或当时没想清楚的是，在B中找A[i]需要log(n)的时间，但其实不需要找A[i]，直接找B[(m+n)/2 -i]作比较就行，是O[1]的时间，这样，整体就是O(log(n+m))。 此方法是在此处有描述：http://www2.myoops.org/course_material/mit/NR/rdonlyres/Electrical-Engineering-and-Computer-Science/6-046JFall-2005/30C68118-E436-4FE3-8C79-6BAFBB07D935/0/ps9sol.pdf
3. 另外的方法是：http://leetcode.com/2011/03/median-of-two-sorted-arrays.html 这篇文章提到的方法自己也承认，太复杂太难写了。其思想是先找A的中位数和B的中位数比大小，然后可得到两个数组都可舍弃一半，但舍弃的时候两个数组要舍弃同样数目的数字，这样才能继续实施算法时，新数组们的中位数是原两数组的中位数。
4. 一开始以为要对第一个和第二个中位数分别查找（n+m为偶数时），后来发现只要找到第一个中位数，第二个要么出现在同数组右边，要么在对应数组固定位置。
5. 使用推荐的做法编程时，发现是个很难写对的程序，需要考虑很多情况，同时经常有小错误。
6. 发现个小办法有点用：从最小的数组开始，然后慢慢变大。比如{1} {2,3} => {1,4} {2,3}，这样能用较少的次数在纸上覆盖较多的情况。
7. 先多列出一些test case。无论面试还是写程序，都会有好处。

class Result
{
public int[] array;
public int index;
}

public class Solution {
public double findMedianSortedArrays(int A[], int B[]) {
// Start typing your Java solution below
// DO NOT write main() function

// special cases
if (A.length == 0){
if (B.length % 2 == 0)
{
return (B[B.length / 2 - 1] + B[B.length / 2]) / 2.0;
}
else
{
return B[B.length / 2];
}
}
else if (B.length == 0)
{
if (A.length % 2 == 0)
{
return (A[A.length / 2 - 1] + A[A.length / 2]) / 2.0;
}
else
{
return A[A.length / 2];
}
}
else if (A.length == 1 && B.length == 1)
{
return (A[0] + B[0]) / 2.0;
}

Result r = findMedFromFirstArray(A, B);
if (r.index == Integer.MIN_VALUE){
r = findMedFromFirstArray(B, A);
}
if (( A.length + B.length) % 2 == 0) // need to find med2
{
int med2 = findMed2(r, A, B);
return (r.array[r.index] + med2) / 2.0;
}
else
{
return r.array[r.index];
}

}

private Result findMedFromFirstArray(int A[], int B[])
{
int la = 0;
int ra = A.length - 1;
int total = 0;
if (( A.length + B.length) % 2 == 0)
{
total = (A.length + B.length)/2 - 2;
}
else
{
total = (A.length + B.length)/2 - 1;
}
while (la <= ra)
{
int mid = (la + ra) / 2;
int idx =  total - mid;

if ((idx < 0 && (idx + 1) >= 0 && A[mid] <= B[idx + 1]) ||
(idx >= 0 && idx < B.length && idx + 1 >= B.length && B[idx] <= A[mid]) ||
(idx >= 0 && idx + 1 < B.length && B[idx] <= A[mid] && A[mid] <= B[idx + 1]))
{
Result r = new Result();
r.index = mid;
r.array = A;
return r;
}
if (idx >= B.length)
{
la = mid+1;
}
else if (idx < 0)
{
ra = mid-1;
}
else if (B[idx] > A[mid])
{
la = mid + 1;
}
else
{
ra = mid - 1;
}
}
Result r = new Result();
r.index = Integer.MIN_VALUE; // this means not find
r.array = A;
return r;
}

private int findMed2(Result r, int ArrayA[], int ArrayB[])
{
int target1 = Integer.MAX_VALUE;
int target2 = Integer.MAX_VALUE;
int[] A = ArrayA;
int[] B = ArrayB;
if (r.array == B)
{
A = ArrayB;
B = ArrayA;
}
{
if (r.index + 1 < A.length)
{
target1 = A[r.index + 1];
}
int idx = ( A.length + B.length) / 2 - 2 - r.index + 1;
if (idx >= 0 && idx < B.length)
{
target2 = B[idx];
}

if (target1 < target2)
{
return target1;
}
else
{
return target2;
}
}
}

}

Discuss上有这段代码，理解一下，基本上是在A中折半猜是不是中位数，A中没有后在B中猜。最后猜到B[j]<=A[i]<=B[j+1]，此时，无论奇偶（2k+1或者2k个），A[i]都是第k+1那个。那么奇数时，A[i]是正中的那个；偶数时，A[i]是中位数两个里大的那个，小的那个要从B[j]和A[i-1]里选一个。

double findMedian(int A[], int B[], int l, int r, int nA, int nB) {
if (l > r)
return findMedian(B, A, max(0, (nA+nB)/2-nA), min(nB, (nA+nB)/2), nB, nA);
int i = (l+r)/2;
int j = (nA+nB)/2 – i – 1;
if (j ≥ 0 && A[i] < B[j]) return findMedian(A, B, i+1, r, nA, nB);
else if (j < nB-1 && A[i] > B[j+1]) return findMedian(A, B, l, i-1, nA, nB);
else {
if ( (nA+nB)%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;
}
}