LeetCode:合并两个有序数组

题目描述

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

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

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]

---

解法一

先无序合并再排序（最简单）

import java.util.Arrays;
import java.util.Scanner;

public class Merge_Sort {
    public void merge(int[] nums1,int m,int[] nums2,int n){
     //第一种解法：合并后利用Array.sort排序
        for (int i = m; i <m+n; i++) {
            nums1[i]=nums2[i-m];
        }
        Arrays.sort(nums1);
        for (int k = 0; k < m+n; k++) {
            System.out.println(nums1[k]);
        }
    }
    public static void main(String[] args) {
        Merge_Sort nums=new Merge_Sort();
        Scanner input=new Scanner(System.in);
        int m,n;
        m=input.nextInt();
        n=input.nextInt();
        int[] nums1=new int[m+n];
        int[] nums2=new int[n];
        for (int i = 0; i < m; i++) {
            nums1[i]=input.nextInt();
        }
        for (int j = 0; j < n; j++) {
            nums2[j]=input.nextInt();
        }
        nums.merge(nums1,m,nums2,n);
    }
}

---

解法二

双指针法：从头开始遍历更小的放入到新的数组(最常规的做法）
注意：因为指针是从头部开始的，所以最好把数据存到新的数组中 这样避免nums1被覆盖

import java.util.Scanner;
public class Merge_Sort {
    public void merge(int[] nums1,int m,int[] nums2,int n){
    //第一种解法：双指针法
      int i=0,j=0,t=0;
        int[] nums3=new int[m+n];
        while (j<n){
            if (nums1[i]<=nums2[j]){
                nums3[t++]=nums1[i++];
            }
            else {
                nums3[t++]=nums2[j++];
            }
        }
        while (i<m){
            nums3[t++]=nums1[i++];
        }
        //将合并好的有序数组放到nums1
        for (i = 0;  i<m+n ; i++) {
            nums1[i]=nums3[i];
        }
        for (int k = 0; k < m+n; k++) {
            System.out.println(nums1[k]);
        }
    }
    public static void main(String[] args) {
        Merge_Sort nums=new Merge_Sort();
        Scanner input=new Scanner(System.in);
        int m,n;
        m=input.nextInt();
        n=input.nextInt();
        int[] nums1=new int[m+n];
        int[] nums2=new int[n];
        for (int i = 0; i < m; i++) {
            nums1[i]=input.nextInt();
        }
        for (int j = 0; j < n; j++) {
            nums2[j]=input.nextInt();
        }
        nums.merge(nums1,m,nums2,n);
    }
}

---

解法三

反向指针法：指针从尾部开始，将更大的数放到nums1的后面（因为nums1的长度为m+n）
注意：
（1）要考虑到nums1和nums2没有元素的情况即i==-1的情况（因为从尾部开始i=m-1） 否则会报错;而且一开始就要判断和处理这种情况,否则-1的情况只能在数组的判断中被报错 而不是被处理。（如果不能理解 可以试试如果不判断或者把该判断放到后面的情况）
（2）指针的移动问题：原先在代码中t的位置我是写成i+n的，但是这样会造成一个问题就是 在else的情况时 i+n不会往前移。（如果不能理解可以在草稿纸上演示一遍 记录一下位置的变化就很容易发现问题）

例如：
//位置：         0 1 2 3 4
//nums1：        1 2 3 _ _
//nums2：        1 2
当经过第二次指针的移动之后，指针会在nums2的1和nums1的2上，此时i==1，i+n==3，但是在经过第二次指针移动之后i+n应该要==2.所以发现问题。因为在else中i的值没有变所以导致i+t的值也不变，所以需要声明新的变量。

import java.util.Scanner;
public class Merge_Sort {
    public void merge(int[] nums1,int m,int[] nums2,int n){
    //第三种解法：反向指针法
       int i=m-1,j=n-1;
        int t=m+n-1;
        while(j>=0||i>=0){
            if (i==-1){
                nums1[t--]=nums2[j--];
            }
            else if (j==-1){
                nums1[t--]=nums1[i--];
            }
            else if (nums1[i]>nums2[j]){
                nums1[t--]=nums1[i--];
            }
            else {
                nums1[t--]=nums2[j--];
            }
        }
        for (int k = 0; k < m+n; k++) {
            System.out.println(nums1[k]);
        }
    }
    public static void main(String[] args) {
        Merge_Sort nums=new Merge_Sort();
        Scanner input=new Scanner(System.in);
        int m,n;
        m=input.nextInt();
        n=input.nextInt();
        int[] nums1=new int[m+n];
        int[] nums2=new int[n];
        for (int i = 0; i < m; i++) {
            nums1[i]=input.nextInt();
        }
        for (int j = 0; j < n; j++) {
            nums2[j]=input.nextInt();
        }
        nums.merge(nums1,m,nums2,n);
    }
}

---

反向指针更简便的解法（代码量很少）

分析： 跳出循环说明某个数组的长度小于0
此时有这些可能：
1.nums1和nums2都已被排好

2.只有一个数组被排好
（1）nums1排好，nums2未排好 此时需要把nums2复制到nums1 并且不用再找位置 因为能跳出循环说明位置都找好了（而且都在后面，试想一下，如果nums1没有都被移到后面是无法跳出循环的），所以直接复制就好了（其实自己演示一下排序的过程就很好理解了）
（2）nums1未排好，nums2排好 数据本来就是放在自身有顺序的nums1中 所以跳出循环时也不用在排序 因为其被动排好了

import java.util.Scanner;
public class Merge_Sort {
    public void merge(int[] nums1,int m,int[] nums2,int n){
    //第三种解法：反向指针法（更简单）
      int len1=m-1,len2=n-1,len=m+n-1;
        while (len1>=0&&len2>=0){
            nums1[len--]=nums1[len1]>nums2[len2]?nums1[len1--] :nums2[len2--];
        }
        //为什么都是从0位置开始，因为nums1的数据都被有序移到后面去了，而nums2只剩下从0开始到当前len2还没排序的元素，所以都是从0开始，为什么长度是len2+1，那是因为len2实际表示的是数组下标
        System.arraycopy(nums2,0,nums1,0,len2+1);
        for (int k = 0; k < m+n; k++) {
            System.out.println(nums1[k]);
        }
    }
    public static void main(String[] args) {
        Merge_Sort nums=new Merge_Sort();
        Scanner input=new Scanner(System.in);
        int m,n;
        m=input.nextInt();
        n=input.nextInt();
        int[] nums1=new int[m+n];
        int[] nums2=new int[n];
        for (int i = 0; i < m; i++) {
            nums1[i]=input.nextInt();
        }
        for (int j = 0; j < n; j++) {
            nums2[j]=input.nextInt();
        }
        nums.merge(nums1,m,nums2,n);
    }
}

知识补充：
System.arraycopy() 用于数组间的复制
System.arraycopy(Object src, intsrcPos, Object dest, int destPos, int length)

Object src： 源数组
int srcPos： 原数组复制的起始位置
Object dest：目标数组
int destPos： 目标数组被复制的起始位置
int length： 复制的长度