LeetCode：合并两个有序数组

1、题目描述

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

提示：

• nums1.length == m + n

• nums2.length == n

• 0 <= m, n <= 200

• 1 <= m + n <= 200

• -109 <= nums1[i], nums2[j] <= 109

方法1：常规API sort()解题

System.arraycopy(): 把一个数组中某一段字节数据放到另一个数组中。

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

src:源数组;

srcPos:源数组要复制的起始位置;

dest:目的数组;

destPos:目的数组放置的起始位置;

length:复制的长度.

一般的高手，看完上面的定义基本就会用来，不会的话，也可以看看下面的示例。

注意：src 和 dest都必须是同类型或者可以进行转换类型的数组．

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        //方法1：常规的API做法，时间复杂度O((n+m)* log(n+m))，空间复杂度O(1)
        System.arraycopy(nums2,0,nums1,m,n);
        Arrays.sort(nums1);
    }
}

时间复杂度O((n+m)* log(n+m))

空间复杂度O(1)

方法2：双指针-从前往后，使用临时数组

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        //方法2: 双指针法，从前往后，时间复杂度O(n+m) 空间复杂度O（m）
        //使用一个新的数组来存放合并排序后的数组，但是因为题目要求返回的是nums1，
        //因此以nums1作为一个新的数组拍存放合并排序后的，而创建一个新的数组作为原来的nums1数组
        //方法2: 双指针法，从前往后，时间复杂度O(n+m) 空间复杂度O（m）
        //使用一个新的数组来存放合并排序后的数组，但是因为题目要求返回的是nums1，
        //因此以nums1作为一个新的数组拍存放合并排序后的，而创建一个新的数组作为原来的nums1数组
        int[] nums1_copy = new int[m]; //创新的长度为m即可
        System.arraycopy(nums1,0,nums1_copy,0,m);
        int p1=0;  //指向nums1_copy  
        int p2=0;  //指向nums1
        int p=0;   //指向nums1
        while(p1<m && p2<n)  //只要其中一个指针超出范围了，就直接不用继比较了，直接将多余的数值复制过去即可
        {
           nums1[p++] = nums1_copy[p1] < nums2[p2] ? nums1_copy[p1++] : nums2[p2++];  //考虑选择一个数组的数放到nums1的时候，指针才++，所以使用自加的技巧来实现
        }
        if(p1<m){//如果nums_copy还有剩余，即将其剩余部分直接复制过去就行
            System.arraycopy(nums1_copy,p1,nums1,p,m-p1);
        }
        if(p2<n){ //理由同上
            System.arraycopy(nums2,p2,nums1,p,n-p2);
        }
    }
}

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

空间复杂度O（m）

方法3：双指针-从后往前，原数组操作

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {       
     //方法3：双指针法，从后往前，不需要开辟新的数组，浪费空间，因为nums1本来的长度就刚好足够放合并后的长度数组，因此还是在nums1数组上操作，从后往前
        int p1=m-1;//指向nums1 最后一个数
        int p2=n-1;//指向Nums2 最后一个数
        int p=n+m-1;//指向nums1数组最后一个位置
        while(p1 >=0 && p2 >= 0){
            nums1[p--] = nums1[p1] > nums2[p2] ? nums1[p1--] : nums2[p2--];
        }
        System.arraycopy(nums2,0,nums1,0,p2+1);//不管是p1还是p2谁先结束，最终都是需要将nums2剩下的数复制到nums1，即便刚好nums2到0 了，执行该语句也没有什么影响！
    }
}

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

空间复杂度O（1）