【算法题】合并两个有序数组

一、引言

本文旨在深入探讨LeetCode中的一道经典数组题目：合并两个有序数组。此题看似简单，却蕴含着多种解题思路，从最基础的直接合并排序，到更高效的双指针法，再到空间复杂度更优的逆向双指针法，每种方法都体现了不同的算法思想和优化策略。通过对这道题目的剖析，掌握具体的解题技巧，更能够领悟到如何根据问题特性选择合适的算法，以及如何对算法进行优化以达到更高的效率。

二、题目描述和分析

给两个按 非递减顺序 排列的整数数组 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 中。

分析：所谓 非递减顺序 可以理解为 升序。

三、直接合并后排序

最直观的方法是先将数组 nums2 放进数组 nums1 的尾部，然后直接对整个数组进行排序。最好提前将特殊情况判断返回，可以加快执行时间。

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        if (nums2.empty())
            return;
        if (nums1.empty()) {
            nums1.swap(nums2);
            return;
        }
        for (int i = 0; i < n; ++i) {
            nums1[m + i] = nums2[i];
        }
        sort(nums1.begin(),nums1.end());
    }
};

复杂度分析：

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

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

四、双指针

先前的方法未发挥 nums1 和 nums2 均为有序列表这一优势。现在，我们采取一种更高效的策略：双指针法。设想 nums1 和 nums2 是两个有序的流水线，我们用两个探针 p1 和 p2 分别指向两条流水线的头部。每次迭代，我们都从两个探针指向的元素中挑选出较小的那一个，将其放入最终的结果序列中。

具体的代码实现如下：

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        if (nums2.empty())
            return;
        if (nums1.empty()) {
            nums1.swap(nums2);
            return;
        }
        int p1 = 0, p2 = 0;
        vector<int> sorts;
        sorts.reserve(m+n);
        while(p1 < m || p2 < n) {
            if (p1 == m) {
                sorts.emplace_back(nums2[p2]);
                ++p2;
            } else if (p2 == n)  {
                sorts.emplace_back(nums1[p1]);
                ++p1;
            } else if (nums1[p1] < nums2[p2]) {
                sorts.emplace_back(nums1[p1]);
                ++p1;
            } else {
                sorts.emplace_back(nums2[p2]);
                ++p2;
            }
        }
        nums1.swap(sorts);
    }
};

复杂度分析：

• 时间复杂度：O(m+n)。指针移动单调递增，最多移动m+n次，因此时间复杂度为O(m+n)。

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

五、逆向双指针

先前的做法需要借助临时空间来暂存数据，因为如果直接将元素合并到 nums1，可能会出现未取出的元素被新值覆盖的情况。为了避免这种覆盖，不妨换一个思路：逆向操作！nums1 的尾部空间是空闲的，正好可以作为我们的“安全区”。因此，可以从 nums1 和 nums2 的尾部开始，选取两者中较大的值，并把它放到 nums1 的末尾。

更严谨地说，在任何一个时刻，已经有 $m-p_1-1$ 个 nums1 的元素和$n-p_2-1$ 个 nums2 的元素被放置在了 nums1 的尾部。与此同时，p1 指针之后，nums1 数组还剩下 $m+n-p_1-1$ 个空位。由于 $m+n-p_1-1\ge (m-p_1-1)+(n-p_2-1)$恒成立 (因为这意味着 $p2\ge -1$，这是必然的)，因此 p1 之后始终有足够的空间来容纳待插入的元素，绝对不会发生覆盖 p1 指向的元素的情况。

实现的代码如下：

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        if (nums2.empty())
            return;
        if (nums1.empty()) {
            nums1.swap(nums2);
            return;
        }
        int p1 = m - 1, p2 =  n -1;
        int tail = m + n - 1;
        while (p1 >= 0 || p2 >= 0) {
            if (p1 < 0) {
                nums1[tail] = nums2[p2];
                --tail;
                --p2;
            } else if (p2 < 0) {
                break;
            } else if(nums2[p2] > nums1[p1]) {
                nums1[tail] = nums2[p2];
                --tail;
                --p2;
            } else {
                nums1[tail] = nums1[p1];
                --tail;
                --p1;
            }
        }
    }
};

六、总结

通过对合并两个有序数组这一问题的深入探讨，学习了三种不同的解题方法：直接合并后排序、双指针法以及逆向双指针法。

• 直接合并后排序 简单直观，易于理解，但效率较低，时间复杂度为 O((m+n)log(m+n))。
• 双指针法 利用了数组的有序性，通过两个指针分别遍历两个数组，实现了 O(m+n) 的时间复杂度，但需要额外的 O(m+n) 空间来存储结果。
• 逆向双指针法 在双指针法的基础上进行了优化，避免了额外的空间开销，实现了原地合并，空间复杂度降为 O(1)，是本题的最优解法。

如果对空间复杂度要求较高，逆向双指针法无疑是最佳选择；如果对时间复杂度要求不高，且有足够的内存空间，双指针法也是一个不错的选择；而直接合并后排序则适用于数据规模较小的情况。