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

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
 

提示：

nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106

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

本人解法：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        multiset<int> s1;
        double res;
        int length=0;
        for(auto it=nums1.begin();it!=nums1.end();it++)
        {
            s1.insert(*it);
            length++;
        }
        for(auto it=nums2.begin();it!=nums2.end();it++)
        {
            s1.insert(*it);
            length++;
        }

        if(length%2==0)
        {
            
            int i = 0;
            for (auto it = s1.begin();; it++, i++)
            {
                if ((length / 2) == i)
                {
                    double d1 = *it;
                    it--;
                    double d2 = *it;
                    res = (d1 + d2) / 2;
                    break;
                }
	        }
        }
        else
        {
            int i = 0;
            for (auto it = s1.begin();; it++, i++)
            {
                if ((length / 2) == i) {
                    res=*it;
                    break;
                }
            }
        }

        return res;
        
    }
};

思路是将两个数组合并，然后根据数组长度是奇数偶数找出中位数

运用了multiset容器，将nums1,nums2的数字全放进去，然后multiset里就会自动排序，然后根据数组长度确定中位数的位置。

思路简单 时间复杂度o(m+n)

leetcode官方解法（划分数组）：

该问题的关键问题就是要找到中位数，但不一定需要将数组合并，如上面我的解法就没有用到两数组有序这一条件

而划分数组则运用到了这一条件，且我们要找到一条分割线，该分割线要满足：

1.第一个数组分割线右边最小的元素大于等于第二个数组分割线左边最大的元素

2.第二个数组分割线右边最小的元素大于等于第一个数组分割线左边最大的元素

这样就能保证分割线右边的元素均大于等于分割线左边的元素

进一步的，若第一个数组与第二个数组长度之和是偶数，则中位数为分割线左侧最大的元素与分割线右侧最小的元素之和的一半；

若为奇数，令分割线左侧元素个数比右侧元素个数多一个，则中位数即为左侧元素最大的那个。

为了代码的可读性，我们令m为nums1长度，n为nums2长度,且m<=n

合并后的数组的左边元素个数tl=(m+n+1)/2

解法运用到的算法是二分查找，通过二分查找找出最大的满足第一个数组分割线右边最小的元素大于等于第二个数组分割线左边最大的元素。

如何实现：left为0，right为第一个数组长度，令i=（left+right）/2，j=tl-i，此时i在第一个数组表示的是i前有几个元素，而j表示第二数组j前有几个元素，比较nums1[i-1]与nums2[j]，

若nums1[i-1]<=nums[j]，说明要找的那个元素在i的右边，则改变二分查找的范围，即变为[i+1,right]，并记下此时的median1和median2

若nums1[i-1]>nums[j]，说明要找的元素在i的左边，二分查找范围变为[left,i-1]

一直重复上述步骤直到left>right，此时不满足循环条件，退出循环

最后对一些特殊情况进行处理，如i在0处，则nums[i-1]定义为无穷小,i在m处，nums[i]定义为无穷大，同理j也是如此；若nums1的长度大于nums2的，则交换两数组。

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        if (nums1.size() > nums2.size()) {
            return findMedianSortedArrays(nums2, nums1);
        }
        
        int m = nums1.size();
        int n = nums2.size();
        int left = 0, right = m;
        // median1：前一部分的最大值
        // median2：后一部分的最小值
        int median1 = 0, median2 = 0;

        while (left <= right) {
            // 前一部分包含 nums1[0 .. i-1] 和 nums2[0 .. j-1]
            // 后一部分包含 nums1[i .. m-1] 和 nums2[j .. n-1]
            int i = (left + right) / 2;
            int j = (m + n + 1) / 2 - i;

            // nums_im1, nums_i, nums_jm1, nums_j 分别表示 nums1[i-1], nums1[i], nums2[j-1], nums2[j]
            int nums_im1 = (i == 0 ? INT_MIN : nums1[i - 1]);
            int nums_i = (i == m ? INT_MAX : nums1[i]);
            int nums_jm1 = (j == 0 ? INT_MIN : nums2[j - 1]);
            int nums_j = (j == n ? INT_MAX : nums2[j]);

            if (nums_im1 <= nums_j) {
                median1 = max(nums_im1, nums_jm1);
                median2 = min(nums_i, nums_j);
                left = i + 1;
            } else {
                right = i - 1;
            }
        }

        return (m + n) % 2 == 0 ? (median1 + median2) / 2.0 : median1;
    }
};