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

法一：首先我直接想到的方法是直接合并然后再排序再取出中位数，时间复杂度是O((m+n)log(m+n))，不满足题目要求，也是最低效的方法。

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        nums1.extend(nums2)
        nums1.sort()
        len1=len(nums1)
        if len1%2>0:
            return nums1[(len1-1)//2]
        else:
            return (nums1[len1//2]+nums1[len1//2-1])/2

法二：
按照插入排序的思路，两个数组都有序可以逐个插入，插到中位数时就停止。事件复杂度是O(m+n)，也不符合要求

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        idx,i,j=0,0,0
        pre_val,this_val=0,0
        len1,len2=len(nums1),len(nums2)
        target_idx=(len1+len2)//2
        while idx<=target_idx:
            if i<len1 and j<len2:
                if nums1[i]<nums2[j]:
                    pre_val=this_val
                    this_val=nums1[i]
                    i+=1  
                else:
                    pre_val=this_val
                    this_val=nums2[j]
                    j+=1
                idx+=1
            elif i<len1:
                pre_val=this_val
                this_idx=target_idx-idx+i
                this_val=nums1[this_idx]
                if this_idx>i:
                    pre_val=nums1[this_idx-1]
                break
            else:
                pre_val=this_val
                this_idx=target_idx-idx+j
                this_val=nums2[this_idx]
                if this_idx>j:
                    pre_val=nums2[this_idx-1] 
                break
        
        return this_val if (len1+len2)%2 else (this_val+pre_val)/2

法三：
事件复杂度是log(m+n)，按道理是二分的思路，不过没想出来，发现按照寻找第k最小数的思路完美解决。寻找第k最小数思路如下：
首先在两个有序序列nums1,nums2中各取前k1=floor(k/2)个数字，若nums1[k1-1]<=nums2[k1-1]，那么nums1中0~k-1个数字可以直接排除，一定不可能存在第k小数，原因
反证法：若nums1 0 ~ k-1中存在第k小数，那么nums1[k1-1]至少要比k-1个数大，但是nums1[k1-1]最多只比2k1-2=2floor(k/2)-2个数字大，明显不足k-1，所以说明nums1的0 ~ k1-1中不存在第k小数，于是，在接下来的序列中继续来找第k-k1小数，递归便可以解决。
需要注意特殊情况下的处理，序列长度不够，以及一个序列长度为空。

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        def recursive(start1,start2,k):
            if start1==len(nums1):
                return nums2[start2+k-1]
            if start2==len(nums2):
                return nums1[start1+k-1]
            if k==1:
                return min(nums1[start1],nums2[start2])
            m=min(k//2,len(nums1)-start1,len(nums2)-start2)
            idx1,idx2=start1+m-1,start2+m-1
            if nums1[idx1]<nums2[idx2]:
                return recursive(idx1+1,start2,k-m)
            return recursive(start1,idx2+1,k-m)
        len12=len(nums1)+len(nums2)
        if len12%2:
            return recursive(0,0,len12//2+1)
        return (recursive(0,0,len12//2)+recursive(0,0,len12//2+1))/2

注意：len求list，tupple，str等对象的长度并不需要遍历，而是通过调用对象自身的__len__()方法来获得，而__len__()方法直接读取对象的长度，时间复杂度O(1)。