Leetcode: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

这道题首先一定是按照二分法的思想进行解答，最开始的想法是对两个有序数组分别进行二分，每次减少左边和右边的一半长度，经过分析发现，这样的算法有可能会将有效的中位数值减去。所以一定要固定左右两边分割的数组地长度。

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

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

如果理解了中位数的划分作用，我们就很接近答案了。

首先，让我们在任一位置 iii 将 A\text{A}A 划分成两个部分：

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

由于 A\text{A}A 中有 mmm 个元素， 所以我们有 m+1m+1m+1 种划分的方法（i=0∼mi = 0 \sim mi=0∼m）。

我们知道：

len(left_A)=i,len(right_A)=m−i\text{len}(\text{left\_A}) = i, \text{len}(\text{right\_A}) = m - ilen(left_A)=i,len(right_A)=m−i.

注意：当 i=0i = 0i=0 时，left_A\text{left\_A}left_A 为空集， 而当 i=mi = mi=m 时, right_A\text{right\_A}right_A 为空集。

采用同样的方式，我们在任一位置 jjj 将 B\text{B}B 划分成两个部分：

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

将 left_A\text{left\_A}left_A 和 left_B\text{left\_B}left_B 放入一个集合，并将 right_A\text{right\_A}right_A 和 right_B\text{right\_B}right_B 放入另一个集合。 再把这两个新的集合分别命名为 left_part\text{left\_part}left_part 和 right_part\text{right\_part}right_part：

          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]

以下为C++代码：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        if(nums1.size() < nums2.size())
            return func(nums1, nums2);
        else
            return func(nums2, nums1);
    }
    
    double func(vector<int>& nums1, vector<int>& nums2){
        int m = nums1.size();
        int n = nums2.size();
        
        int mmax = m, mmin = 0, halflen = (m + n + 1) / 2;
        while(mmin <= mmax){
            int i = (mmin + mmax) / 2;
            int j = halflen - i;
            
            if ( i > mmin && nums1[i - 1] > nums2[j] ){
                mmax = i - 1;
                
            }
            
            else if (i < mmax && nums2[j - 1] > nums1[i] ){
                mmin = i + 1;
            }
            else{
                int maxleft = 0;
                if(i == 0)
                    maxleft = nums2[j - 1];
                else if(j == 0)
                    maxleft = nums1[i - 1];
                else
                    maxleft = 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 = min(nums1[i], nums2[j]);
                
                return (minright + maxleft) / 2.0;      
            }
        }
        return 0.0;
    }
    
};