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

分析：

方法1：快速排序

最简单的方式，将 B 的数字复制到 A 的末端，然后对 A 进行快速排序。

时间复杂度：O((m+n)^log(m+n))         m，n 为两个数组的长度
空间复杂度：O(log(m+n))

class Solution {
    public void merge(int[] A, int m, int[] B, int n) {
        //将B的值赋到A的末端
        for(int i = 0; i < n; ++i){
            A[m+i] = B[i];
        }
        //排序
        quickSort(A, 0, m + n - 1);
    }

    //快速排序
    public void quickSort(int[] arr, int start, int end){
        if(start >= end){
            return;
        }
        //定义指针
        int i = start, j = end, temp = arr[start];
        //遍历
        while(i < j){
            while(i < j && arr[j] >= temp){
                j--;
            }
            while(i < j && arr[i] <= temp){
                i++;
            }
            //交换
            int tt = arr[i];
            arr[i] = arr[j];
            arr[j] = tt;
        }
        //交换
        arr[start] = arr[i];
        arr[i] = temp;
        //继续对两边进行操作
        quickSort(arr, i+1, end);
        quickSort(arr, start, i-1);
    }
}

方法2：归并排序（双指针）

因为两个数组都是排好序的，因此我们可以利用这一点进行归并排序。定义双指针分别指向两个数组末位（A 指向有数的末位），每次比较筛选出最大值放在 A 的末位，直到遍历完成。A 的真实末位可以额外定义一个指针。

时间复杂度：O(m+n)         m，n 为两个数组的长度
空间复杂度：O(1)

class Solution {
    public void merge(int[] A, int m, int[] B, int n) {
        //定义双指针
        int i = m-1, j = n-1, k = A.length - 1;
        //遍历
        while(i >= 0 && j >= 0){
            //A中元素比B大
            if(A[i] >= B[j]){
                A[k--] = A[i--];
            }
            else{
                A[k--] = B[j--];
            }
        }
        //复制没比较完的
        while(j >= 0){
            A[k--] = B[j--];
        }
    }
}

题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sorted-merge-lcci