4. 寻找两个正序数组的中位数 力扣 c++

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。

解法一：时间复杂度为O(m+n)，空间复杂度O(m+n)。
先合并两个有序数组，然后根据数组下标求出中位数

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int len1=nums1.size();
        int len2=nums2.size();
        vector<int> tmp(len1+len2,0);
        int i=0,j=0,k=0;
        while(i<len1&&j<len2)
        {
            if(nums1[i]>nums2[j])
            {
                tmp[k]=nums2[j];
                j++;
            }
            else
            {
                tmp[k]=nums1[i];
                i++;
            }
            k++;
        }
        while(i<len1)
        {
            tmp[k]=nums1[i];
            i++;
            k++;
        }
        while(j<len2)
        {
            tmp[k]=nums2[j];
            j++;
            k++;
        }
        int total=len1+len2;
        if(total%2==1)
        {
            return double(tmp[total/2]);
        }
        else
        {
            int index=total/2;
            return (tmp[index-1]+tmp[index])/2.0;
        }
        
    }
};

解法二：
利用二分查找，时间复杂度O(log(m+n)),空间复杂度O(1)。
不合并两个数组，只要找出中位数的个数即可。维护两个指针，初始时分别指向两个数组的下标0的位置，每次将指向较小值的指针后移一位，如果一个指针已经到达数组尾部，只需要移动另一个数组的指针，直到到达中位数的位置。
对于数组A、B我们比较A[k/2-1]和B[k/2-1]的值，
如果A[k/2-1]>B[k/2-1]，则比A[k/2-1]要小的树最多包括A[0]-A[k/2-2],B也是同理，则比A[k/2-1]小的最多只有k-2个数，我们将删除B[k/2-1]自身及之前的数；
如果A[k/2-1]<B[k/2-1],我们删除A[0]到A[k/2-1]；
如果A[k/2-1]==B[k/2-1],我们将其合并到第一种情况中。

class Solution {
public:
    int getKthElement(const vector<int>&nums1,const vector<int>&nums2,int k)
    {
        int m=nums1.size();
        int n=nums2.size();
        int index1=0,index2=0;
        while(1)
        {
            // 边界情况
            // nums1到尾，则中位数在nums2中，直接返回nums2[index2+k-1]
            if(index1==m)
                return nums2[index2+k-1];
            if(index2==n)
                return nums1[index1+k-1];
            // 返回两个数组的第一个元素的最小值
            if(k==1)
                return min(nums1[index1],nums2[index2]);
            // 正常情况
            // 重新计算新的索引保证不越界，然后获取nums1[newIndex1]、nums2[newIndex2]的值作为比较的中位数
            int newIndex1=min(index1+k/2-1,m-1);
            int newIndex2=min(index2+k/2-1,n-1);
            int pivot1=nums1[newIndex1];
            int pivot2=nums2[newIndex2];
            // 根据比较结果更新数组的下标索引，并更新k的值
            if(pivot1<=pivot2)
            {
                k-=newIndex1-index1+1;
                index1=newIndex1+1;
            }
            else
            {
                k-=newIndex2-index2+1;
                index2=newIndex2+1;
            }
            // 循环会不断缩小 k 的值，直到找到第 k 小的元素。
        }
    }
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
    {
       int totalLen=nums1.size()+nums2.size();
       if(totalLen%2==1)
            return getKthElement(nums1,nums2,(totalLen+1)/2);
        else
            return (getKthElement(nums1,nums2,totalLen/2)+getKthElement(nums1,nums2,totalLen/2+1))*0.5;
    }
    }
};