LeetCode:寻找两个正序数组的中位数----多种解题方式_给定两个大小分别为 m 和 n 的正序(从小到大)数组 nums1 和 nums2。请你找出并返

写在前面：在学习算法中我们会学到很多经典的算法，双指针，二分查找等等，但是这只是一种思想，解题时我们可以灵活的运用，也不必局限一种形式，要将学到的东西，转换成自己的东西。

题目

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

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

举例

实例1：

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

实例2：

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

注意本题在力扣中不用返回的数据不用考虑小数位数，系统会自动保留对应的位数

思路一 运用归并排序的思想，双指针

因为这是两个有序数组，在两个有序数组中寻找中位数，可以先考虑将两个数组合并起来，然后找中位数

有序数组的合并比较简单，就是用两个指针分别指向两个数组的开头，依次比较指针指向的数字，较少的数字添加到新数组，指针加1，然后再重复以上的循环，直至其中一个指针越界。最后将未添加完的数字合并到新数组中

详细的流程看代码

def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
    l1 = 0
    l2 = 0
    r1 = len(nums1)
    r2 = len(nums2)
    arr = []
    while True:  # 循环添加
        if l1>r1-1 or l2>r2-1:  # 当有一个数组的数据被添加完成，就跳出循环
            break
        if nums1[l1] > nums2[l2]:
            arr.append(nums2[l2])
            l2+=1
        else:
            arr.append(nums1[l1])
            l1+=1
	# 添加未合并完成的数组
    if l1!=r1:
        arr.extend(nums1[l1:])
    elif l2!=r2:
        arr.extend(nums2[l2:])
    # 根据数组长度的奇偶返回不同的值
    if (r1+r2)%2==0:
        return (arr[((r1+r2)//2)-1]+arr[(r1+r2)//2])/2
    else:
        return arr[(r1+r2)//2]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

我们能发现上面这个解题方式中，我们使用了额外的一个数组，浪费了内存空间，因为是两个有序数组，目的又是找出中位数，所以我们可以直接找出中位数，而不用进行合并

思路二 运用归并排序的思想，双指针

这个算法也是用了两个指针，使用情况同第一个类似，只不过我们比较大小后不进行合并，就是用应给变量记录比较的次数，直至比较的次数==中位数的位置，此时我们再根据具体的情况返回具体的值
具体的思路请看代码

def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
    l1 = 0 
    l2 = 0
    r1 = len(nums1)
    r2 = len(nums2)
    number = 0   # 记录次数
    f = 0 # 标志数组是奇数还是偶数
    
    # 根据奇偶设置中间的元素位置
    if (r1+r2)%2==0: 
        f = 2
        mid = (r1+r2)//2   
    else:
        f = 1
        mid = (r1+r2)//2+1
        
    while True:
        if l1>r1-1 or l2>r2-1:
            break
        if nums1[l1] > nums2[l2]: 
            number+=1
            if number == mid: # 当number等于mid的时候就代表此时已经到了中位数的位置
                if f==1:   # 奇数情况
                    return nums2[l2]  
                else:      # 偶数情况
                    if l2==r2-1:  # 此时l2指向其中nums2的最后一个元素
                        return (nums2[l2]+nums1[l1])/2
                    else:
                    	# 返回两种情况中最小的
                        return min(nums2[l2]+nums2[l2+1],nums2[l2]+nums1[l1])/2
            l2+=1 
        else:   # 同上思想一样，对象更换了一下
            number+=1
            if number == mid:
                if f==1:
                    return nums1[l1]
                else:
                    if l1==r1-1:
                        return (nums2[l2]+nums1[l1])/2
                    else:       
                        return min(nums1[l1]+nums1[l1+1],nums2[l2]+nums1[l1])/2
            l1+=1
        
    # 这种是当一个数组特别长，中位数在其中一个数组中的情况
    if l1!=r1:
        if f==1:
            return nums1[mid-l2-1]
        else:
            return (nums1[mid-l2-1]+nums1[mid-l2])/2
    elif l2!=r2:
        if f==1:
            return nums2[mid-l1-1]
        else:
            return (nums2[mid-l1-1]+nums2[mid-l1])/2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

此时我们能够发现上面的两种解法的时间复杂度不是 O(log (m+n))，原因就是我们合并和排除数字都是一个一个的进行的 时间复杂度为 O(m+n)
想要实现O(log (m+n))的时间复杂度，我们可以回想一下什么情况出现log，二分法，此时我们的思路就明朗了，解题需要使用二分的思想，每次排除的数字，都应该是原数据的二分之一

思路三 使用二分查找法

def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
    if len(nums1) > len(nums2):
    	# 保证数组nums1是较短的哪一个
        return self.findMedianSortedArrays(nums2, nums1)

    infinty = 10*6+1  # 
    m, n = len(nums1), len(nums2)
    left, right = 0, m  # 只需要记录记录第一个数组的指针，第二个数组可以计算出来
    # median1：前一部分的最大值
    # median2：后一部分的最小值
    median1, median2 = 0, 0

    while left <= right:   # 循环条件
        # 前一部分包含 nums1[0 .. i-1] 和 nums2[0 .. j-1]
        # // 后一部分包含 nums1[i .. m-1] 和 nums2[j .. n-1]
        i = (left + right) // 2   # 通过计算确定二分后的中间位置 nums1
        j = (m + n + 1) // 2 - i  # 根据规则计算nums2的需要分的位置
        
       # nums_im1, nums_i, nums_jm1, nums_j 分别表示 nums1[i-1], nums1[i], nums2[j-1], nums2[j]
        # 四个数字 看数字是否符合条件
        nums_im1 = (-infinty if i == 0 else nums1[i - 1])  # 当i为0时
        nums_i = (infinty if i == m else nums1[i])
        nums_jm1 = (-infinty if j == 0 else nums2[j - 1])  # 当j为0时
        nums_j = (infinty if j == n else nums2[j])

        if nums_im1 <= nums_j: 
        	# 满足这个条件的median1, median2 不一定时最后结果，但是最后结果一定满足这个条件
			# 当出现最后结果 left将不在改变，直至循环结束
            median1, median2 = max(nums_im1, nums_jm1), min(nums_i, nums_j)
            # 取分割线左侧的最大值，取分割线右侧的最小值
            left = i + 1
        else:
            right = i - 1
	# 根据奇偶的不同返回不同的结果
    return (median1 + median2) / 2 if (m + n) % 2 == 0 else median1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

最后一个我自己的代码太罗嗦了，就使用的是力扣官方的代码。
具体的讲解请大家移步力扣官方