leetCode 4. Median of Two Sorted Arrays

There are two sorted arrays nums1 and nums2 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)).

You may assume nums1 and nums2 cannot be both empty.

Example 1:

nums1 = [1, 3]
nums2 = [2]

The median is 2.0

Example 2:

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

基本思路是：

　　每次从num2中取边界内[low2,high2)的中间数mid2，查找该数在num1中的位置loc，计算loc左边和mid2左边的数的个数，判断mid2是否是计算中位数需要的数。

　　由于每次是折半（num2中使用），且使用二分查找(num1中使用)，故其时间复杂度为log(m+n)。

　　每次取第二个数组的中间数mid2，故需要记录第二个数组的范围，即low2，high2（mid2=（low2+high2）/2），在第一个数组中利用二分查找查找mid2，二分查找的结果是一个范围：若找到，则返回的是mid2的位置，否则返回的是[l,r]，其中（num1[l]<mid2<num1[r]）满足l=r-1; 

　　计算num1中 l 左边(包括 l 位置)和mid2左边(包括mid2)的数字的个数res，

　　若res==totalLength/2 且 totalLength为偶数，则中位数一定是两个数(left，right)的平均数，又因为 l 位置(包括 l 位置)左边和mid2(不包括mid2)左边的数都<=mid2，故mid2一定是left，right要么是num1中r位置的数(若该下标存在),要么是mid2右边的数(若存在)。

　　另外还有其他情况，这里不做分析。

　　主要是越界的判断有些繁琐，我觉得这恰恰是一种调试技巧，编程时尽可能的考虑每一种情况，即使意识到这种情况可能不存在，也要留出语句做判断，这在调试的时候会很省劲，因为可能自己意识错误。

 

class Solution {
    class Pair {
        int mid1;
        int mid2;

        public Pair(int mid1, int mid2) {
            this.mid1 = mid1;
            this.mid2 = mid2;
        }
    }

    public Pair binarySearch(int[] a, int target) {
        int low = 0, high = a.length, mid = (low + high) / 2;
        while (low <= high && low < a.length) {
            mid = (low + high) / 2;
            if (a[mid] == target) {
                while (mid<a.length-1 && a[mid+1]==target) ++mid;
                return new Pair(mid, mid);
            } else if (target < a[mid]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        Pair pair = null;
        if (low == mid) {
            if (mid > high) {
                int t = mid;
                mid = high;
                high = t;
            }
            pair = new Pair(mid, high);
        } else {
            if (low > mid) {
                int t = low;
                low = mid;
                mid = t;
            }
            pair = new Pair(low, mid);
        }
        return pair;
    }

    public double result(int[] nums1, int low1, int high1, int[] nums2, int low2, int high2) {
        int totalLength = nums1.length + nums2.length;
        int mid1, mid2;
        int right = -1, left = -1;
        boolean isOdd = (totalLength % 2 == 0) ? false : true;

        while (low2 <= high2 && low2< nums2.length && high2<= nums2.length) {// && res <= totalLength / 2
            mid2 = (low2 + high2) / 2;
            Pair pair = binarySearch(nums1, nums2[mid2]);
            int res = pair.mid1 + 1 + mid2 + 1;
            if (res == totalLength / 2) {
                if (!isOdd) { //总个数为偶数
                    if (pair.mid1 > 0) {
                        if (pair.mid1 + 1 >= nums1.length) {
                            if (mid2 == nums2.length - 1) {
                                System.out.println("目测这种情况不会发生1");
                            } else {
                                return (nums2[mid2]+nums2[mid2+1])/2.0;
                            }
                        } else {
                            if (mid2 == nums2.length - 1) {
                                return (nums2[mid2] + nums1[pair.mid1+1])/2.0;
                            } else {
                                left = nums2[mid2];
                                right = (nums1[pair.mid1 + 1] > nums2[mid2 + 1]) ? nums2[mid2 + 1] : nums1[pair.mid1 + 1];
                            }
                        }
                        return (left + right) / 2.0;
                    } else {
                        if (mid2 >= 0 && mid2 < nums2.length) {
                            left = nums2[mid2];
                            if (mid2+1>=nums2.length){
                                right= nums1[pair.mid1+1];
                            }else {
                                right= nums1[pair.mid1+1] > nums2[mid2+1]?nums2[mid2+1]:nums1[pair.mid1+1];
                            }
                        } else {
                            System.out.println("目测这种情况不会发生3");
                        }
                        return (left + right) / 2.0;
                    }
                } else { // 总个数为奇数
                    if (pair.mid1+1< nums1.length){
                        if (nums2.length==1){
                            return nums1[pair.mid1+1];
                        }
                        if (mid2+1< nums2.length){
                            return nums1[pair.mid1+1] < nums2[mid2+1]?nums1[pair.mid1+1]:nums2[mid2+1];
                        }else {
                            return nums1[pair.mid1+1];
                        }
                    }else {
                        return nums2[mid2+1];
                    }
                }
            }
            if (res == totalLength / 2 + 1) {
                if (!isOdd) { // 总个数为偶数
                    if (pair.mid1 == -1){
                        return (nums2[mid2]+nums2[mid2-1])/2.0;
                    }else {
                        if (mid2-1>=0) {
                            left = (nums1[pair.mid1] > nums2[mid2 - 1]) ? nums1[pair.mid1] : nums2[mid2 - 1];
                            right = nums2[mid2];
                            return (left + right) / 2.0;
                        }else {
                            left = pair.mid1;
                            right = mid2;
                            return (nums1[left] + nums2[right]) / 2.0;
                        }
                    }
                } else { // 总个数为奇数
                    return nums2[mid2];
                }
            }
            if (res<totalLength/2+1){
                low2=mid2+1;
            }else {
                high2=mid2-1;
            }
        }
        return -1.0;
    }

    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        /**
         * 当某个数组为空时单独判断
         * */
        int left=-1,right=-1;
        if (nums1.length==0){
            if (nums2.length==0){
                System.out.println("目测这种情况不会发生5");
            }else {
                if (nums2.length%2==0){
                    left=nums2[nums2.length/2-1];
                    right=nums2[nums2.length/2];
                    return (left+right)/2.0;
                }else {
                    return nums2[nums2.length/2];
                }
            }
        }
        if (nums2.length==0){
            if (nums1.length==0){
                System.out.println("目测这种情况不会发生6");
            }else {
                if (nums1.length%2==0){
                    left=nums1[nums1.length/2-1];
                    right=nums1[nums1.length/2];
                    return (left+right)/2.0;
                }else {
                    return nums1[nums1.length/2];
                }
            }
        }
        if (nums1.length==1 && nums2.length==1){
            return (nums1[0]+nums2[0])/2.0;
        }
        double res = result(nums1, 0, nums1.length, nums2, 0, nums2.length);
        if (res == -1)
            return result(nums2,0,nums2.length,nums1,0, nums1.length);
        return res;
    }
}