4. Median of Two Sorted Arrays

思路：分治法
计算中位数的左边需要剔除多少个数，然后剔除，并取出中位数。
例如：
[1,4]
[2,3,5,7]
可以知道中位数需要取出2个作平均，在这两个中位数左边需要排除掉2个数。

先找出nums1和nums2的中位数，如上为4和5（本算法实现如此），把4放到nums2中看看，发现，比4小的有2和3，所以，总的比4小的有1,2,3。 超出了总共需要排除的总数（2）， 所以，需要排除的2个数，就在{1,2,3}里面继续找。递归分治……

public class Solution {
    // [beg, end)
    public int indexMiddle(int beg, int end) {
        return beg + (end - beg) / 2;
    }

    // return the index of first number in nums[beg, end) that bigger than
    // num
    public int binarySearch(int[] nums, int beg, int end, int num) {
        if (end - 1 == beg) {
            if (nums[beg] >= num)
                return beg;
            else
                return beg + 1;
        }
        int mid = indexMiddle(beg, end);
        if (num < nums[mid]) {
            return binarySearch(nums, beg, mid, num);
        } else {
            return binarySearch(nums, mid, end, num);
        }
    }

    public double findMedian(int[] nums1, int[] nums2, int beg1, int end1, int beg2, int end2, int passedNum, int numShouldPass) {

        if (beg1 == end1 || beg2 == end2 || passedNum + 1 >= numShouldPass) {
            int p1 = beg1, p2 = beg2;
            int times = numShouldPass - passedNum + 1 + ((nums1.length + nums2.length) % 2 == 0 ? 1 : 0);
            int count = 0;
            int sum = 0, min = 0;
            while (count < times) {
                min = Integer.MAX_VALUE;
                int minPointer = -1; // 默认nums1[beg1]
                if (nums1.length > p1 && nums1[p1] < min) {
                    min = nums1[p1];
                    minPointer = 1;
                }
                if (nums2.length > p2 && nums2[p2] < min) {
                    min = nums2[p2];
                    minPointer = 2;
                }
                if (minPointer == 1)
                    p1++;
                else
                    p2++;

                if (count >= numShouldPass - passedNum)
                    sum += min;
                count++;
            }
            if ((nums1.length + nums2.length) % 2 == 0)
                return ((double) (sum) / 2);
            else
                return (double) sum;

        }

        int mid1 = 0, mid2 = 0;
        int idx;
        mid1 = indexMiddle(beg1, end1);
        mid2 = indexMiddle(beg2, end2);
        if (nums1[mid1] <= nums2[mid2]) {
            idx = binarySearch(nums2, beg2, end2, nums1[mid1]);
            if (mid1 == beg1 && idx == beg2) {
                if (nums1[mid1] <= nums2[idx]) {
                    mid1++;
                } else {
                    idx++;
                }
            }
            int passNumNow = mid1 - beg1 + idx - beg2;

            if (passedNum + passNumNow > numShouldPass) {
                return findMedian(nums1, nums2, beg1, mid1, beg2, idx, passedNum, numShouldPass);
            } else {
                return findMedian(nums1, nums2, mid1, end1, idx, end2, passedNum + passNumNow, numShouldPass);
            }
        } else {
            idx = binarySearch(nums1, beg1, end1, nums2[mid2]);
            if (mid2 == beg2 && idx == beg1) {
                if (nums2[mid2] <= nums1[idx]) {
                    mid2++;
                } else {
                    idx++;
                }
            }
            int passNumNow = mid2 - beg2 + idx - beg1;
            if (passedNum + passNumNow > numShouldPass) {
                return findMedian(nums1, nums2, beg1, idx, beg2, mid2, passedNum, numShouldPass);
            } else {
                return findMedian(nums1, nums2, idx, end1, mid2, end2, passedNum + passNumNow, numShouldPass);
            }
        }
    }

    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int beg1 = 0, end1 = nums1.length; // nums1[beg1, end1)
        int beg2 = 0, end2 = nums2.length; // nums2[beg2, end2)
        int passedNum = 0;
        int numShouldPass = ((nums1.length + nums2.length) % 2 == 0) ? (nums1.length + nums2.length) / 2 - 1 : (nums1.length + nums2.length) / 2;
        return findMedian(nums1, nums2, beg1, end1, beg2, end2, passedNum, numShouldPass);
    }
}