Median of two Sorted Arrays (Frequent++)

http://www.lintcode.com/en/problem/median-of-two-sorted-arrays/

题目：找到两个长度分别为m和n的已排序数组的中数 （等同于找两已排序数组的第k大的元素）

时间复杂度为O(log(m + n))

解答：参考 http://www.cnblogs.com/yuzhangcmu/p/4138184.html

          比较两数组的第k/2个数，将较小的那组数的1~k/2个数舍弃，继续比较，直到k == 1。需考虑某个数组为空的情况

第一次错误：持续比较至k == 0，但是当k == 1时， A[k / 2 -1] 和 B[k / 2 - 1] 超出范围；

解决：持续比较至k == 1，为保证递归次数正确（奇数情况），每次返回findKth(X, X, (k + 1) / 2)

第二次错误：判断数组是否为空，if（A != null) 不够， 需要 if (A != null && A.length != 0)

class Solution {
    /**
     * @param A: An integer array.
     * @param B: An integer array.
     * @return: a double whose format is *.5 or *.0
     */
    public double findMedianSortedArrays(int[] A, int[] B) {
        // write your code here 
        int len = A.length + B.length;
        if (len % 2 == 1) {
           return findKth(A, B, len / 2 + 1);
        } else {
            return (findKth(A, B, len / 2) + findKth(A, B, len / 2 + 1)) / 2.0;
        }
    }
    
    private int findKth(int[] A, int[] B, int k) {
        if (A == null || A.length == 0) {
            return B[k - 1];
        }
        if (B == null || B.length == 0) {
            return A[k - 1];
        }
        if (k == 1) {
            return Math.min(A[0], B[0]);
        }
        
        if (A.length < k / 2) {
            int[] C = new int[B.length - k / 2];
            for (int i = k / 2; i < B.length; i++) {
                C[i - k / 2] = B[i];
            }
            return findKth(A, C, (k + 1) / 2);
        } else if (B.length < k / 2) {
            int[] C = new int[A.length - k / 2];
            for (int i = k / 2; i < A.length; i++) {
                C[i - k / 2] = A[i];
            }
            return findKth(C, B, (k + 1) / 2);
        } else {
            if (A[k / 2 -1] <= B[k / 2 - 1]) {
                int[] C = new int[A.length - k / 2];
                for (int i = k / 2; i < A.length; i++) {
                    C[i - k / 2] = A[i];
                }
                return findKth(C, B, (k + 1) / 2);
            } else {
                int[] C = new int[B.length - k / 2];
                for (int i = k / 2; i < B.length; i++) {
                   C[i - k / 2] = B[i];
                }
                return findKth(A, C, (k + 1) / 2);
            }
        }
    }
}