Leecode_88.合并两个有序数组

1.题目：

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

1.1 示例：

示例 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 中。

1.2 提示：

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

2. 3种解法：

2.1 解法1：直接合并后排序

【思路】最直观的方法是先将数组 nums2放进数组 nums1
的尾部，然后直接对整个数组进行排序。

【Python3代码-来自LeeCode官方】

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        nums1[m:] = nums2
        nums1.sort()

【解析】LeeCode官方给出的代码真的是短小精悍哈哈哈。这段代码最巧妙的地方就是 nums1[m:] = nums2 这句了，利用了Python列表切片的性质直接将 nums2 拼在了 nums1 后面。然后直接调用了 Python 内置的 sort()方法。可以说是非常容易理解了。

【复杂度分析】
时间复杂度：O((m+n)log(m+n))。 排序序列长度为 m+n，套用快速排序的时间复杂度即可，平均情况为 O((m+n)log⁡(m+n))。

空间复杂度：O(log⁡(m+n))。 排序序列长度为 m+n，套用快速排序的空间复杂度即可，平均情况为 O(log⁡(m+n))。

不清楚快速排序的小伙伴戳这里： 快速排序算法

2.2 解法2：双指针法

【思路】方法一没有利用数组 nums1与 nums2 已经被排序 的性质。为了利用这一性质，我们可以使用双指针方法。这一方法将两个数组看作队列，每次从两个数组头部取出比较小的数字放到结果中。
我们为两个数组分别设置一个指针 p1p2 来作为队列的头部指针。
【解析】
① 因为 nums1 和 nums2 都是有序数组，而按照题目的要求合并后的数组也要是有序数组，且顺序为“非递减”，所以合并后的数组是按照从小到大的顺序排列。所以双指针方法思路的雏形就出来了：从 nums1 和 nums2 依次找较小元素然后插入。上面的动图就非常直观啦。
② 注意题目是将数组看作 “队列”，这里只需要知道队列的基本性质“先进先出”，对应到本题就是：当从 nums1 或者 nums2 中取出一个元素时，p1 或者 p2 就要向后移动一位。

【Python3代码-来自LeeCode官方】

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        sorted = []
        p1, p2 = 0, 0
        while p1 < m or p2 < n:
            if p1 == m:
                sorted.append(nums2[p2])
                p2 += 1
            elif p2 == n:
                sorted.append(nums1[p1])
                p1 += 1
            elif nums1[p1] < nums2[p2]:
                sorted.append(nums1[p1])
                p1 += 1
            else:
                sorted.append(nums2[p2])
                p2 += 1
        nums1[:] = sorted

【解析】
① 首先要注意 p1, p2 的值初始化为0，所以一开始进入 while 循环，肯定是从 elif nums1[p1] < nums2[p2] 这里开始执行的，直到 p1 递增到 m 或者 p2 递增到 n 才会执行前两个判断。
② 再次需要注意的是 while 循环的条件是：p1 < m or p2 < n ，即 p1 < m 或者 p2 < n 这两个条件满足任一一个即可执行循环体。所以就会出现两种情况：
a. p1 < m , p2 = n 满足循环条件；
b. p1 = m , p2 < n 满足循环条件
③ 当 p1 = m 的时候，说明 nums1 数组中的所有元素已经比较完毕并且全部存放了，只剩下 nums2 中 指针p2 所指位置及以后的元素没有被存放，且由于 nums2 是排序好的，所以直接挨个存放就好了。同理 p2 = n 的情况。

【复杂度分析】
时间复杂度：O(m+n)。 指针移动单调递增，最多移动 m+n 次，因此时间复杂度为 O(m+n)。
【解析】这里可以直接看 while 循环最多执行多少次，根据 while 循环的条件可以知道 while 循环最多执行 m+n 次。

空间复杂度：O(m+n)。 需要建立长度为 m+n 的中间数组 sorted。

2.3 解法3：逆向双指针

【思路】方法二中，之所以要使用临时变量，是因为如果直接合并到数组 nums1中，nums1中的元素可能会在取出之前被覆盖。那么如何直接避免覆盖 nums1中的元素呢？观察可知，nums1的后半部分是空的，可以直接覆盖而不会影响结果。因此可以指针设置为从后向前遍历，每次取两者之中的较大者放进 nums1 的最后面。严格来说，在此遍历过程中的任意一个时刻，nums1数组中有 m−p1−1个元素被放入 nums1的后半部分，nums2
​数组中有 n−p2−1个元素被放入 nums1的后半部，而在指针 p1的后面，nums1数组有 m+n−p1−1 个位置。
由于 ：m+n−p1−1 ≥ m−p1−1+n−p2−1
等价于：p2 ≥ −1 永远成立，
因此 p1 后面的位置永远足够容纳被插入的元素，不会产生 p1的元素被覆盖的情况。
【解析】
① 解法3的思路中首先就说明了为什么解法2要使用一个中间变量sorted数组。
② 解法2是从正向考虑，给出了从小到大的合并数组，那么反过来当然也可以先找出最大的元素，放在合并数组的最后，循环进行这一步直到结束。基于这种情况，会不会出现覆盖的情况呢？思路中也给出了相关的数学证明。画图解释一下：“在此遍历过程中的任意一个时刻，nums1数组中有 m−p1−1个元素被放入 nums1的后半部分，nums2​数组中有 n−p2−1个元素被放入 nums1的后半部”这句话。

【Python3代码-来自LeeCode官方】

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        p1, p2 = m - 1, n - 1
        tail = m + n - 1
        while p1 >= 0 or p2 >= 0:
            if p1 == -1:
                nums1[tail] = nums2[p2]
                p2 -= 1
            elif p2 == -1:
                nums1[tail] = nums1[p1]
                p1 -= 1
            elif nums1[p1] > nums2[p2]:
                nums1[tail] = nums1[p1]
                p1 -= 1
            else:
                nums1[tail] = nums2[p2]
                p2 -= 1
            tail -= 1

【解析】
① 首先注意 p1 和 p2 的初始化值，是从 nums1 和 nums2 的尾部开始遍历哦。
② 与方法2 不同的是需要定义一个 tail 指针来指向 nums1 的存放位置。而方法2则是使用了 append() 方法来向数组添加元素，所以不需要定义指针。
③ 代码前2种判断情况理解参考算法2。
④ 需要注意的一点就是无论执行哪一种if 判断情况，执行完毕后就已经向 nums1 插入了一个元素，所以 tail 指针都要减去1，为了代码的简洁性所以直接放到最后。

【复杂度分析】
时间复杂度：O(m+n)。 指针移动单调递减，最多移动 m+n次，因此时间复杂度为 O(m+n)。

空间复杂度：O(1)。 直接对数组 nums1原地修改，不需要额外空间。