4. 寻找两个有序数组的中位数

题干

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

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

则中位数是 2.0

示例 2:

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

则中位数是 (2 + 3)/2 = 2.5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解

为了解决这个问题，我们需要理解 “中位数的作用是什么”。在统计中，中位数被用来：

将一个集合划分为两个长度相等的子集，其中一个子集中的元素总是大于另一个子集中的元素。

所以我们只需要将数组进行切割。

一个长度为 m 的数组，有 0 到 m 总共 m + 1 个位置可以切割。

我们把数组 A 和数组 B 分别在 i 和 j 进行切割。

将 i 的左边和 j 的左边组合成「左半部分」，将 i 的右边和 j 的右边组合成「右半部分」。

• 当 A 数组和 B 数组的总长度是偶数时，如果我们能够保证

1. 左半部分的长度等于右半部分

i + j = m - i  + n - j  , 也就是 j = ( m + n ) / 2 - i

2. 左半部分最大的值小于等于右半部分最小的值 max ( A [ i - 1 ] , B [ j - 1 ]）） <= min ( A [ i ] , B [ j ]））

那么，中位数就可以表示如下

（左半部分最大值 + 右半部分最小值 ）/ 2。

（max ( A [ i - 1 ] , B [  j  - 1 ]）+ min ( A [ i ] , B [ j ]）） /  2

• 当 A 数组和 B 数组的总长度是奇数时，如果我们能够保证

1. 左半部分的长度比右半部分大 1

  i + j = m - i  + n - j  + 1也就是 j = ( m + n + 1) / 2 - i

2. 左半部分最大的值小于等于右半部分最小的值 max ( A [ i - 1 ] , B [ j - 1 ]）） <= min ( A [ i ] , B [ j ]））

那么，中位数就是

左半部分最大值，也就是左半部比右半部分多出的那一个数。

max ( A [ i - 1 ] , B [  j - 1 ]）

上边的第一个条件我们其实可以合并为j = ( m + n + 1) / 2 - i，因为如果m + n 是偶数，由于我们取的是 int 值，所以加 1 也不会影响结果。当然，由于0 <= i <= m ，为了保证0 <= j <= n，我们必须保证m <= n。

m≤n, i<m, j=(m+n+1)/2−i≥(m+m+1)/2−i>(m+m+1)/2−m=0

m≤n, i>0, j=(m+n+1)/2−i≤(n+n+1)/2−i<(n+n+1)/2=n

最后一步由于是 int 间的运算，所以 1/2=0。

而对于第二个条件，奇数和偶数的情况是一样的，我们进一步分析。为了保证max ( A [ i - 1 ] , B [ j - 1 ]）） <= min ( A [ i ] , B [ j ]）），因为 A 数组和 B 数组是有序的，所以A [ i - 1 ] <= A [ i ]，B [ i - 1 ] <= B [ i ]这是天然的，所以我们只需要保证B [ j - 1 ] < = A [ i ]和A [ i - 1 ] <= B [ j ]所以我们分两种情况讨论：

• B [ j - 1 ] > A [ i ]，并且为了不越界，要保证 j != 0，i != m
  
  此时很明显，我们需要增加 i ，为了数量的平衡还要减少 j ，幸运的是 j = ( m + n + 1) / 2 - i，i 增大，j 自然会减少。
• A [ i - 1 ] > B [ j ] ，并且为了不越界，要保证 i != 0，j != n

此时和上边的情况相反，我们要减少 i ，增大 j 。

上边两种情况，我们把边界都排除了，需要单独讨论。

• 当 i = 0, 或者 j = 0，也就是切在了最前边。
  
  此时左半部分当 j = 0 时，最大的值就是 A [ i - 1 ] ；当 i = 0 时 最大的值就是 B [ j - 1] 。右半部分最小值和之前一样。

• 当 i = m 或者 j = n，也就是切在了最后边。
  
  此时左半部分最大值和之前一样。右半部分当 j = n 时，最小值就是 A [ i ] ；当 i = m 时，最小值就是B [ j ] 。

所有的思路都理清了，最后一个问题，增加 i 的方式。当然用二分了。初始化 i 为中间的值，然后减半找中间的，减半找中间的，减半找中间的直到答案。

class Solution {
    public double findMedianSortedArrays(int[] A, int[] B) {
        int m = A.length;
        int n = B.length;
        if (m > n) { 
            return findMedianSortedArrays(B,A); // 保证 m <= n
        }
        int iMin = 0, iMax = m;
        while (iMin <= iMax) {
            int i = (iMin + iMax) / 2;
            int j = (m + n + 1) / 2 - i;
            if (j != 0 && i != m && B[j-1] > A[i]){ // i 需要增大
                iMin = i + 1; 
            }
            else if (i != 0 && j != n && A[i-1] > B[j]) { // i 需要减小
                iMax = i - 1; 
            }
            else { // 达到要求，并且将边界条件列出来单独考虑
                int maxLeft = 0;//左半部分最大值
                if (i == 0) 
                	{ maxLeft = B[j-1]; }
                else if (j == 0) 
                	{ maxLeft = A[i-1]; }
                else 
                	{ maxLeft = Math.max(A[i-1], B[j-1]); }
                
                if ( (m + n) % 2 == 1 ) 
                	{ return maxLeft; } // 奇数的话不需要考虑右半部分

                int minRight = 0;//右半部分最小值
                if (i == m) 
                	{ minRight = B[j]; }
                else if (j == n) 
                	{ minRight = A[i]; }
                else 
                	{ minRight = Math.min(B[j], A[i]); }

                return (maxLeft + minRight) / 2.0; //如果是偶数的话返回结果
            }
        }
        return 0.0;
    }
}

• 时间复杂度：我们对较短的数组进行了二分查找，所以时间复杂度是 O(log（min（m，n））。

• 空间复杂度：只有一些固定的变量，和数组长度无关，所以空间复杂度是 O(1)。

作者：windliang
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-w-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。