合并排序后的数组（转自leetcode）

给定两个排序后的数组 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]
说明:

A.length == n + m
通过次数46,049提交次数84,272

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sorted-merge-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法一：直接合并后排序
算法

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

C++JavaPython3GolangJavaScriptC

class Solution {
    public void merge(int[] A, int m, int[] B, int n) {
        for (int i = 0; i != n; ++i) {
            A[m + i] = B[i];
        }
        Arrays.sort(A);
    }
}
复杂度分析

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

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

方法二：双指针
算法

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

我们为两个数组分别设置一个指针 \textit{pa}pa 与 \textit{pb}pb 来作为队列的头部指针。代码实现如下：

C++JavaPython3GolangJavaScriptC

class Solution {
    public void merge(int[] A, int m, int[] B, int n) {
        int pa = 0, pb = 0;
        int[] sorted = new int[m + n];
        int 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 (int i = 0; i != m + n; ++i) {
            A[i] = sorted[i];
        }
    }
}
复杂度分析

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

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

方法三：逆向双指针
算法

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

严格来说，在此遍历过程中的任意一个时刻，AA 数组中有 m-\textit{pa}-1m−pa−1 个元素被放入 AA 的后半部，BB 数组中有 n-\textit{pb}-1n−pb−1 个元素被放入 AA 的后半部，而在指针 \textit{pa}pa 的后面，AA 数组有 m+n-\textit{pa}-1m+n−pa−1 个位置。由于

m+n-\textit{pa}-1\geq m-\textit{pa}-1+n-\textit{pb}-1
m+n−pa−1≥m−pa−1+n−pb−1

等价于

pb\geq -1
pb≥−1

永远成立，因此 \textit{pa}pa 后面的位置永远足够容纳被插入的元素，不会产生 \textit{pa}pa 的元素被覆盖的情况。

实现代码如下：

C++JavaPython3GolangJavaScriptC

class Solution {
    public void merge(int[] A, int m, int[] B, int n) {
        int pa = m - 1, pb = n - 1;
        int tail = m + n - 1;
        int 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)O(m+n)。
指针移动单调递减，最多移动 m+nm+n 次，因此时间复杂度为 O(m+n)O(m+n)。

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

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/sorted-merge-lcci/solution/mian-shi-ti-1001-he-bing-pai-xu-de-shu-zu-by-leetc/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。