【LeetCode】88 合并两个有序数组（java）—— 简单

目录

1. 题目描述

2. 算法思路

3. 算法代码

4. 时空复杂度分析

---

1. 题目描述

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

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

 2. 算法思路

方法一：直接合并后排序

    思路：
        1）将数组nums2放进数组nums1的尾部
        2）直接对整个数组进行排序
    
    处理：使用for循环，nums2放进数组nums1的尾部，从m到m+n-1（nums1数组下标从0开始）

方法二：双指针
   
    思路：
        1）利用数组nums1与nums2已经有序的性质
        2）每次从两个数组头部取出比较小的数字放到结果数组sorted中

    处理：
        1）定义一个新的结果数组sorted
        2）给数组nums1、nums2分别设置一个指针p1、p2作为头部指针
        3）逐个比较两个数组中指针p1和p2所指值的大小，较小的值放进sorted中，指针
右移，依次比较，得到结果数组

方法三：逆向双指针

    思路：将数组nums1和nums2从后向前（尾部）逐个比较，较大的一个放在nums1的最后面，
依次比较。

    处理：
        1）设置两个尾部指针p1=m-1,p2=n-1，设置当前元素要插入nums1的尾部的指针tail
        2）m=0时，即p1=-1，nums1为空数组，直接把nums2逐个插入到nums1
        3）n=0时，即p2=-1，nums2为空数组
        4）nums1[p1]>nums2[p2]时，nums1[p1]插入到nums1的尾部，否则nums2[p2]插入到
nums1尾部

3. 算法代码

import java.util.Arrays;

/**
 * @Author: 张晴晴
 * @Date: 2021/12/11 
 * @Description: 合并两个有序数组
 */
public class 合并两个有序数组88 {
    public static void main(String[] args) {
        int[] nums1 = {1, 2, 3, 0, 0, 0};
        int[] nums2 = {2, 5, 6};
        int m = 3;
        int n = 3;
//        merge(nums1, m, nums2, n);
//        System.out.println(Arrays.toString(nums1));
//        merge2(nums1, m, nums2, n);
//        System.out.println(Arrays.toString(nums1));
//        merge3(nums1, m, nums2, n);
//        System.out.println(Arrays.toString(nums1));
        merge4(nums1, m, nums2, n);
        System.out.println(Arrays.toString(nums1));
    }

    /**
     * 直接合并后排序
     *
     * @param nums1
     * @param m
     * @param nums2
     * @param n
     * @return
     */
    public static void merge(int[] nums1, int m, int[] nums2, int n) {
        if (n >= 0) System.arraycopy(nums2, 0, nums1, m, n);
        Arrays.sort(nums1);
    }

    /**
     * 直接合并后排序
     *
     * @param nums1
     * @param m
     * @param nums2
     * @param n
     * @return
     */
    public static void merge2(int[] nums1, int m, int[] nums2, int n) {
        for (int i = 0; i < n; i++) {
            nums1[m + i] = nums2[i];
        }
        Arrays.sort(nums1);
    }

    /**
     * 双指针（使用临时变量sorted）
     *
     * @param nums1
     * @param m
     * @param nums2
     * @param n
     */
    public static void merge3(int[] nums1, int m, int[] nums2, int n) {
        int p1 = 0, p2 = 0; //p1为num1的头部指针；p2为num2的头部指针
        int[] sorted = new int[m + n];
        int cur; //cur指针指向sorted的当前元素
        while (p1 < m || p2 < n) {
            if (p1 == m) {
                cur = nums2[p2++];
            } else if (p2 == n) {
                cur = nums1[p1++];
            } else if (nums1[p1] < nums2[p2]) {
                cur = nums1[p1++];
            } else {
                cur = nums2[p2++];
            }
            sorted[p1 + p2 - 1] = cur;
        }
//        if (m + n >= 0) System.arraycopy(sorted, 0, num1, 0, m + n);
        for (int i = 0; i < m + n; i++) {
            nums1[i] = sorted[i];
        }
    }

    /**
     * 逆向双指针（不适用临时变量sorted）
     *
     * @param nums1
     * @param m
     * @param nums2
     * @param n
     */
    public static void merge4(int[] nums1, int m, int[] nums2, int n) {
        int p1 = m - 1, p2 = n - 1;
        int tail = nums1.length - 1;
        int cur;
        while (p1 >= 0 || p2 >= 0) {
            if (p1 == -1) { //num1为空，直接把num2中的元素放到num1中
                cur = nums2[p2--];
            } else if (p2 == -1) { //num2为空
                cur = nums1[p1--];
            } else if (nums1[p1] > nums2[p2]) {
                cur = nums1[p1--];
            } else {
                cur = nums2[p2--];
            }
            nums1[tail--] = cur;
        }
    }
}

4. 时空复杂度分析

直接合并后排序：
    时间复杂度：O((m+n)log(m+n))，排序序列长度为m+n
    空间复杂度：O(log(m+n))

双指针：
    时间复杂度：O(m+n)，指针移动单调递增，最多移动m+n次。
    空间复杂度：O(m+n)，需要建立长度为m+n的中间数组sorted。

逆向双指针：
    时间复杂度：O(m+n)，指针移动单调递减，最多移动m+n次。
    空间复杂度：O(1)，直接对数组nums1原地修改，不需要额外空间。