#leetcode#Median of Two Sorted Arrays

网上各种各样的解答， 还是code ganker大牛的思路最简单明了。

这里handle了一下invalid input， 

用找 kth element of sorted arrays的思路， 所以每次递归k - posA  或者 k - posB也就不难理解了， 找第k个元素么， 砍掉小的半边， 就把砍掉的个数减去， 而砍掉大得部分的时候无需对k进行修改。

if(numA > numB){
            return helper(B, A, startB, endB, startA, endA, k);
        }

限定了A是长度较短的那个， 所以确定positionA的时候要考虑A的长度比 k/2 小的情况。

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

空间复杂度递归栈的大小 O（log（m+n））

public class Solution {
    public double findMedianSortedArrays(int[] A, int[] B) {
        if(A == null || B == null){
            throw new IllegalArgumentException("invalid input");
        }
        int lenA = A.length;
        int lenB = B.length;
        int len = lenA + lenB;
        if(len % 2 == 0){
            double r1 = (double)helper(A, B, 0, lenA - 1, 0, lenB - 1, len / 2);
            double r2 = (double)helper(A, B, 0, lenA - 1, 0, lenB - 1, len / 2 + 1);
            return (r1 + r2) / 2;
        }
        return (double)helper(A, B, 0, lenA - 1, 0, lenB - 1, len / 2 + 1);
    }
    
    private int helper(int[] A, int[] B, int startA, int endA, int startB, int endB, int k){
        int numA = endA - startA + 1;
        int numB = endB - startB + 1;
        if(numA > numB){
            return helper(B, A, startB, endB, startA, endA, k);
        }
        if(numA <= 0){
            return B[startB + k - 1];
        }
        if(k == 1){
            return Math.min(A[startA], B[startB]);
        }
        int posA = Math.min(numA, k / 2);
        int posB = k - posA;
        if(A[startA + posA - 1] < B[startB + posB - 1]){
            return helper(A, B, startA + posA, endA, startB, startB + posB - 1, k - posA);
        }else{
            return helper(A, B, startA, startA + posA - 1, startB + posB, endB, k - posB);
        }
    }
}