题目
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2,另有两个整数 m 和 n ,分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中,使合并后的数组同样按 非递减顺序 排列。
注意:最终,合并后数组不应由函数返回,而是存储在数组 nums1 中。为了应对这种情况,nums1 的初始长度为 m + n,其中前 m 个元素表示应合并的元素,后 n 个元素为 0 ,应忽略。nums2 的长度为 n 。
思路一: 直接将第二个数组nums2填充到nums1后面,再针对nums1排序
思路二:双指针
定义两个整型变量作为两个数组的指针,初始时都指向数组的起始位置,由于两个数组均为升序排列,每次比较两个指针所指向的元素,将值小的放在新的数组中,接着控制指针向下走,直到其中一个数组全部被遍历,这时直接将另一个数组中的所有元素放在其后面即可。
思路三:反向双指针
在思路二中,虽然时间复杂度相比于思路一降低了不少,但是由于重新定义了一个数组,空间复杂度依旧很高,我们可以考虑逆向思维,反着排序,因为nums1数组后面部分没有被赋值,我们考虑倒着存储,就可以解决空间复杂度较高的问题。可能有的童鞋会有疑问——会不会存在数组元素的覆盖。其实不会,想要覆盖nums1中元素的前提是后面[0,0,0……]部分全部放满了,这种情况下代表nums2中元素已经全部遍历了,故不会出现覆盖的情况。
java代码如下
package demo;
import java.util.Arrays;
public class leetcode4 {
//思路一
public void merge(int[] nums1, int m, int[] nums2, int n) {
for(int i=m;i<m+n;i++){
nums1[i]=nums2[i-m];
}
Arrays.sort(nums1);
for(int i:nums1){
System.out.println(i);
}
}
//思路二
public void merge_doublepoint(int[] nums1, int m, int[] nums2, int n){
int p1=0;
int p2=0;
int temp;
int[] num=new int[m+n];
while(p1<m||p2<n){
if(p1==m) {
temp = nums2[p2++];
}
else if(p2==n){
temp=nums1[p1++];
}
else if(nums1[p1]<nums2[p2]){
temp=nums1[p1++];
}
else{
temp=nums2[p2++];
}
num[p1+p2-1]=temp;
}
for(int i=0;i<m+n;i++){
nums1[i]=num[i];
System.out.println(nums1[i]);
}
}
//思路三
public void merge_reverspoint(int[] nums1, int m, int[] nums2, int n){
int p1=m-1;
int p2=n-1;
int total=m+n-1;
while(p1>=0||p2>=0){
if(p1==-1) {
nums1[total--] = nums2[p2--];
}
else if(p2==-1){
nums1[total--]=nums1[p1--];
}
else if(nums1[p1]<nums2[p2]){
nums1[total--]=nums2[p2--];
}
else{
nums1[total--]=nums1[p1--];
}
}
for(int i=0;i<m+n;i++){
System.out.println(nums1[i]);
}
}
}
class test4{
public static void main(String arg[]){
leetcode4 l=new leetcode4();
int[] nums1={1,2,4,0,0};
int[] nums2={1,5};
int m=3;
int n=2;
//思路一
l.merge(nums1,m,nums2,n);
//思路二
l.merge_doublepoint(nums1,m,nums2,n);
//思路三
l.merge_reverspoint(nums1,m,nums2,n);
}
}
复杂度分析
思路一
思路二
思路三