【LeetCode】4. Median of Two Sorted Arrays - Java实现

1. 题目描述：

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)).

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

2. 思路分析：

题目大意就是找出2个有序数组的中位数。如果是奇数个，则中位数就是中间那个数，如果是偶数个，则中位数就是中间2个数的平均数。

这一题难度级别较高，是hard级别的。主要是题目要求时间复杂度为O(log (m+n))，这就比较难。

如果要求时间复杂度为O(m+n)，则很简单，思路就和merge两个有序数组思想类似，见下面代码1的实现。

而本题要求时间复杂度为O(log (m+n))，看到这种时间复杂度很容易往二分查找方向想，那么这题就可以转变成一个类似二分查找的思路。

我们把A数组分成2部分，左边部分有i个数，右边有m-i个数，如下所示：

          left_A             |        right_A
    A[0], A[1], ..., A[i-1]  |  A[i], A[i+1], ..., A[m-1]

同样，把B数组分成2部分，左边部分有j个数，右边有n-j个数，如下所示：

          left_B             |        right_B
    B[0], B[1], ..., B[j-1]  |  B[j], B[j+1], ..., B[n-1]

我们让 i + j = (m + n) / 2，则我们就将2个数组分成了左右个数相等的2部分，如下所示：

          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]

当A[i-1] < B[j] 并且 A[i] > B[j-1]时，中位数就找到了。当m+n为奇数时，中位数就是左边最大的数；当m+n为偶数时，中位数就是左边最大的数和右边最小的数的平均值。

所以问题就转换成：找到这样一个满足条件的i的值。

当A[i-1] > B[j]时，表示i的值偏大了，这个时候就要减小i的值，相应的j的值就要增大；
当A[i] < B[j-1]时，表示i的值偏小了，这个时候就要增大i的值，相应的j的值就要减小；
如此一直调整i的值，直到找到满足条件的i的值，则找到了中位数。
实现代码见下面代码2

3. Java代码：

源代码：见我GiHub主页

代码1：时间复杂度O(m+n)

public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
    int i = 0;
    int j = 0;
    int len = nums1.length + nums2.length;
    int k = len / 2;
    int prev = 0;
    int cur = 0;
    while (i < nums1.length && j < nums2.length && i + j <= k) {
        if (nums1[i] < nums2[j]) {
            prev = cur;
            cur = nums1[i];
            i++;
        } else {
            prev = cur;
            cur = nums2[j];
            j++;
        }
    }
    while (i < nums1.length && i + j <= k) {
        prev = cur;
        cur = nums1[i];
        i++;
    }
    while (j < nums2.length && i + j <= k) {
        prev = cur;
        cur = nums2[j];
        j++;
    }
    if (len % 2 == 0) {
        return (prev + cur) / 2.0;
    } else {
        return cur;
    }
}

代码2：时间复杂度为O(log (m+n))

public static double findMedianSortedArrays2(int[] nums1, int[] nums2) {
    int m = nums1.length;
    int n = nums2.length;
    // 保证m<n, 避免j出现负数
    if (m > n) {
        int[] tempArray = nums1;
        nums1 = nums2;
        nums2 = tempArray;
        int temp = m;
        m = n;
        n = temp;
    }
    int halfLen = (m + n + 1) / 2;
    int iMin = 0;
    int iMax = m;
    while (iMin <= iMax) {
        int i = (iMin + iMax) / 2;
        int j = halfLen - i;
        if (i < m && nums1[i] < nums2[j - 1]) { // i的值偏小
            iMin = i + 1;
        } else if (i > 0 && nums1[i - 1] > nums2[j]) { // i的值偏大
            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 ((m + n) % 2 == 1) {
                return maxLeft;
            }
            int minRight = 0;
            if (i == m) {
                minRight = nums2[j];
            } else if (j == n) {
                minRight = nums1[i];
            } else {
                minRight = Math.min(nums1[i], nums2[j]);
            }
            return (maxLeft + minRight) / 2.0;
        }
    }
    return 0.0;
}