（day31）Leecode题——合并两个有序数组

描述

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。

示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

提示：

• nums1.length == m + n
• nums2.length == n
• 0 <= m, n <= 200
• 1 <= m + n <= 200
• -109 <= nums1[i], nums2[j] <= 109

进阶：你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？

小垃圾的代码

用数组2中的元素代替数组1中的0，然后对新生成的数组进行排序。此算法的时间复杂度为O((m+n)log(m+n))，不符合进阶版的要求。

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        for i in range(m,m+n):
            nums1[i] = nums2[i-m]
        nums1.sort()

 Leecode题解灵茶山爱府

错误的思路

如果从左往右地把nums2合并到nums1中，假设nums2[0] < nums1[0]，那么nums[0]会直接覆盖掉nums[0]，这不是我们期望看到的。

正确的思路

如果从右往左地把nums2合并到nums1中，是否会发生错误的覆盖呢?我们来看几个例子:
. nums1= [1,2,3,*, *, *],  nums2= [4,5,6]。这里我用 * 表示可以填入的空位。在这个例子中，nums2可以直接填入nums后面的3个空位，得到[1,2,3,4,5,6]，没有任何错误覆盖。
nums1 = [1,2,6,*, *, *]  , nums2= [3,4.,5]。这里nums1中的6是最大的，应当填入末尾。现在 nums1= [1,2 *,*, *,6]，注意nums1[2]这个位置现在空出了。然后把 nums2中的数字填入空位，得到[1,2,3,4,5,6]，没有任何错误覆盖。
·上面的例子表明，把 nums1中的数字移到另一个空位，又产生了一个新的空位，所以剩余空位的个数是不变的，我们总是有空位可以让nums2的数字填入，不会发生错误覆盖，这是如下算法正确的前提。

算法

1.初始化三个指针p = m -1指向nums1的末尾，p=n -1指向nums2的末尾，p= m+n-1指向合并后的数组末尾。

⒉.不断比较nums1 [p1]和nums2[p2]的大小，将较大的值放入nums1[p]。如果p ≥0且nums[p]更大，那么放入后p1和p减一，否则p2和p减一。注意nums1[p] = nums2[p2]时放入谁都可以，不妨规定放入nums2[p2]。这样在数组元素都相等的情况下，只需要把nums2的数据填入nums1中，效率更高。
3.循环直到 p <0，此时nums2的所有元素均已填入nums1。你可能会想，如果nums1还有元素没有移动呢?注意到当nums2都合并到nums1时, nums1剩余未移动的元素，它要移动的目标位置就是它自己所处的位置，所以无需移动，合并完毕。这可以算作一个小优化，比如nums1= [1,2,3,*,* *], nums2 = [4,5,6]，其实只要把 nums2的所有数都填入nums2中，合并就已经结束了，即便此时p1=2仍然≥0。

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        # 初始化三个指针，分别指向 nums1 和 nums2 的最后一个元素，以及合并后的数组的最后一个位置
        p1, p2, p = m - 1, n - 1, m + n - 1
        
        # 当 nums2 还有元素未合并时
        while p2 >= 0:
            # 如果 nums1 中还有元素，并且 nums1 当前指针指向的元素大于 nums2 当前指针指向的元素
            if p1 >= 0 and nums1[p1] > nums2[p2]:
                # 将 nums1 中较大的元素放到合并后的数组的最后一个位置
                nums1[p] = nums1[p1]
                p1 -= 1  # nums1 的指针左移
            else:
                # 否则，将 nums2 中的元素放到合并后的数组的最后一个位置
                nums1[p] = nums2[p2]
                p2 -= 1  # nums2 的指针左移
            p -= 1  # 合并后数组的指针左移

整体分析：

1. 类定义：

   • 定义了一个 Solution 类，其中包含一个 merge 方法。

2. 方法参数：

   • merge 方法接收四个参数：
     • nums1：第一个排序数组，具有足够的空间来容纳合并后的元素。
     • m：nums1 中初始有效元素的数量。
     • nums2：第二个排序数组。
     • n：nums2 中的元素数量。

3. 初始化指针：

   • p1 初始化为 nums1 的最后一个有效元素的索引（m-1）。
   • p2 初始化为 nums2 的最后一个元素的索引（n-1）。
   • p 初始化为 nums1 最后的索引位置（m+n-1）。

4. 合并过程：

   • 通过一个 while 循环，当 nums2 还有元素未合并时执行。
   • 在循环中，通过比较 nums1 和 nums2 当前指针指向的元素，将较大的元素放到合并后的数组的最后一个位置。
   • 根据比较结果，更新相应的指针位置。

5. 结果：

   • 最终 nums1 中将包含合并后的排序数组。