[路飞]_前端算法一零四弹-合并排序的数组

「这是我参与2022首次更文挑战的第11天，活动详情查看：2022首次更文挑战」

给定两个排序后的数组 A 和 B，其中 A 的末端有足够的缓冲空间容纳 B。 编写一个方法，将 B 合并入 A 并排序。

初始化 A 和 B 的元素数量分别为 m 和 n。

示例:

输入:
A = [1,2,3,0,0,0], m = 3
B = [2,5,6],       n = 3

输出: [1,2,2,3,5,6]

---

直接合并后排序

最直观的方法是先将数组 $B$ 放进数组 $A$ 的尾部，然后直接对整个数组进行排序。

var merge = function(A, m, B, n) {
    A.splice(m, A.length - m, ...B);
    A.sort((a, b) => a - b);
};

复杂度分析

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

双指针

方法一没有利用数组 $A$ 与 $B$ 已经被排序的性质。为了利用这一性质，我们可以使用双指针方法。这一方法将两个数组看作队列，每次从两个数组头部取出比较小的数字放到结果中。

我们为两个数组分别设置一个指针 $pa$ 与 $pb$ 来作为队列的头部指针。

var merge = function(A, m, B, n) {
    let pa = 0, pb = 0;
    const sorted = new Array(m + n).fill(0);
    var cur;
    while (pa < m || pb < n) {
        if (pa === m) {
            cur = B[pb++];
        } else if (pb === n) {
            cur = A[pa++];
        } else if (A[pa] < B[pb]) {
            cur = A[pa++];
        } else {
            cur = B[pb++];
        }
        sorted[pa + pb - 1] = cur;
    }
    for (let i = 0; i != m + n; ++i) {
        A[i] = sorted[i];
    }
};

复杂度分析

• 时间复杂度：$O(m+n)$。

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

• 空间复杂度：$O(m+n)$。

  需要建立长度为 $m+n$ 的中间数组 $sorted$ 。

逆向双指针

方法二中，之所以要使用临时变量，是因为如果直接合并到数组 $A$ 中，$A$ 中的元素可能会在取出之前被覆盖。那么如何直接避免覆盖 $A$ 中的元素呢？观察可知，$A$ 的后半部分是空的，可以直接覆盖而不会影响结果。因此可以指针设置为从后向前遍历，每次取两者之中的较大者放进 $A$ 的最后面。

严格来说，在此遍历过程中的任意一个时刻，$A$ 数组中有 $m−pa−1$ 个元素被放入 $A$ 的后半部，B 数组中有 $n−pb−1$ 个元素被放入 $A$ 的后半部，而在指针 $pa$ 的后面，$A$ 数组有 $m+n−pa−1$ 个位置。

var merge = function(A, m, B, n) {
    let pa = m - 1, pb = n - 1;
    let tail = m + n - 1;
    var cur;
    while (pa >= 0 || pb >= 0) {
        if (pa === -1) {
            cur = B[pb--];
        } else if (pb === -1) {
            cur = A[pa--];
        } else if (A[pa] > B[pb]) {
            cur = A[pa--];
        } else {
            cur = B[pb--];
        }
        A[tail--] = cur;
    }
};

复杂度分析

• 时间复杂度：$O(m+n)$。

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

• 空间复杂度：$O(1)$。

  直接对数组 $A$ 原地修改，不需要额外空间。