leetcode_数据结构_入门_88. 合并两个有序数组

88. 合并 两个 有序数组

问题：
    两个按 非递减顺序 排列的 整数数组 nums1 和 nums2，
    另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素个数。
    请 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：
    最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。
    为了应对这种情况，
    nums1 的初始长度为 m + n，
    其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。
    nums2 的长度为 n 。

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

 代码

main

package DataStructure_start;


import java.util.Arrays;

public class DS20230111 {

    public static void main(String[] args) {
        int[] nums1 = {1,2,3,0,0,0};
        int m = 3;
        int[] nums2 = {2,5,6};
        int n = 3;

        int[] merge = merge(nums1, m, nums2, n);
        int[] merge2 = merge(nums1, m, nums2, n);
//        merge(new int[]{1,2,3},3,new int[]{2,5,6},3);

        System.out.println(Arrays.toString(merge));
        System.out.println(Arrays.toString(merge2));

    }
}

方法一：直接合并后排序

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

复杂度分析

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

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

    public static int[] merge(int[] nums1, int m, int[] nums2, int n) {

        for (int i = 0; i != n; ++i) {
//            1.将 数组nums2 的元素依次插入到 数组nums1 后
            nums1[m + i] = nums2[i];
        }

//        2.再使用Arrays 里的 sort方法（升序排序）将新的 数组nums1 按升序排序
        Arrays.sort(nums1);

        return nums1;

    }

方法二：双指针

双指针，即用两个不同速度或不同方向的指针对数组或对象进行访问，通过两个不同指针的碰撞从而达到特定的目的。


思路：

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

为两个数组分别设置一个指针 p1与 p2来作为队列的头部指针。


复杂度分析

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

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

    public void merge2(int[] nums1, int m, int[] nums2, int n) {

//        为两个数组分别设置一个指针 p1与 p2来作为队列的头部指针。
        int p1 = 0, p2 = 0;
        int[] sorted = new int[m + n];
        int cur;

        while (p1 < m || p2 < n) {
            if (p1 == m) {
                cur = nums2[p2++];
            } else if (p2 == n) {
                cur = nums1[p1++];
//                如果 数组nums2 中 p2指向的数 大于 数组nums1 中 p1指向的数 （排序）★
            } else if (nums1[p1] < nums2[p2]) {
//                则将 指针cur 从 nums1 的 指针p1 后移一位
                cur = nums1[p1++];
            } else {
                cur = nums2[p2++];
            }
//            将 指针cur 指向目前 最后的位置
            sorted[p1 + p2 - 1] = cur;
        }
        for (int i = 0; i != m + n; ++i) {
//            依次放入 数组nums1 里（已排好序）
            nums1[i] = sorted[i];
        }
    }

补充：
    队列
        先进先出
        队尾进，队头出
        一块连续的存储单元

　　快速排序
    　　基准数：通常以第一个数作为基准数
    　　分界点：左边的都小于这个分界点，右边的都大于这个分界点
       　　 交换
    　　意义：是冒泡排序的改进（从两端开始向中间推进）
       　　 快速排序之所以比较快，是因为与冒泡排序相比，每次的交换时跳跃式的，
       　　 每次排序的时候设置一个基准点

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