leetcode之Median of Two Sorted Arrays

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

首先想到的方法一定是归并算法中的按顺序合并两个顺序数组的方法：

public static double findMedianSortedArrays1(int[] nums1, int[] nums2) {
	int m = nums1.length;
	int n = nums2.length;
	int l = m + n;
	int[] nums = new int[l];
	int i = 0, j = 0, k = 0;
	while (i < m && j < n) {
		nums[k++] = nums1[i] < nums2[j] ? nums1[i++] : nums2[j++];
	}
	while (i < m) {
	nums[k++] = nums1[i++];
	}
	while (j < n) {
		nums[k++] = nums2[j++];
	}
	for (int num : nums) {
		System.out.println(num);
	}
	double median = l % 2 == 0 ? (nums[l / 2 - 1] + nums[l / 2]) / 2 : nums[l / 2];
	return median;
}

该方法过于简单，写完后便知道时间只能超过30的人，时间复杂度为O(m+n)
题目中要求时间复杂度为O(log (m+n))，必然需要使用递归法，但由于要判断奇数偶数，还要判断边界条件，着实困扰了我许久。

首先将两个数组分别分为两段：

		  left_part          |        right_part
    A[0], A[1], ..., A[i-1]  |  A[i], A[i+1], ..., A[m-1]
    B[0], B[1], ..., B[j-1]  |  B[j], B[j+1], ..., B[n-1]

对于中位数，需要满足一下两个条件：

1. 左右长度相等：i + j = m - i + n - j
2. 左边最大值小于右边最小值，即：

B[j-1] <= A[i] && A[i-1] <= B[j]

通过表达式 j = (m + n + 1) / 2 - i ，只需判断i位置处是否满足条件2即可，
当i变大时A[i]、A[i-1]变大，j变小，B[j-1]、B[j]变小
因此当B[j-1] > A[i]时，可以将i变大当 A[i-1] > B[j]时，将i变小，直到两个式子都成立。

这里存在边界条件的问题，当i = 0或i = m时，便不需要判断B[j-1] <= A[i] 或A[i-1] <= B[j]，因为A[i-1]或A[i]不存在。

若总长度为奇数，则左边的最大值为中位数
若总长度为偶数，则左边的最大值和右边的最小值为中位数

代码如下：

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length, l = m + n;
        //始终保证num1的长度较小
        if (m > n){
            int[] temp = nums1; 
            nums1 = nums2;
            nums2 = temp;
            int tm = m; m = n; n = tm;
        }
        int iMin = 0, iMax = m , middle = (m + n + 1)/2;
        while(iMin <= iMax){
            int i = (iMin + iMax)/2;
            //条件1导出的i,j之间的关系
            int j = middle - i;
            //条件2的第一式
            if(i < m && nums2[j - 1] > nums1[i]){
                iMin = i + 1;
            }else if(i > 0 && nums1[i - 1] > nums2[j]){ 
            	//条件2的第二式
                iMax = i - 1;
            }else{ 
            	//i已经到达正确的位置，分奇数偶数讨论
                int maxLeft = 0;
                if(i == 0){
                    maxLeft = nums2[j - 1];
                }else if(j == 0){两个链表一样长的情况
                    maxLeft = nums1[i - 1]; 
                }else{
                    maxLeft = Math.max(nums1[i - 1], nums2[j - 1]);
                }
                if(l % 2 == 1)
                    return maxLeft;
                
                int minRight = 0;
                if(i == m){
                    minRight = nums2[j];
                }else if(j == n){
                    minRight = nums1[i];
                }else{
                    minRight = Math.min(nums2[j], nums1[i]);
                }
                return (maxLeft + minRight) / 2.0;
            }
        }
        return 0.0;
    }
}