精华内容
下载资源
问答
  • /*** 合并两个有序数组* 给定两个有序整数数组 nums1 和 nums2,将 nums2 合并到 nums1 中,使得 num1 成为一个有序数组。* * 说明:* * 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。* 你可以假设 nums1 有足够...

    /**

    * 合并两个有序数组

    * 给定两个有序整数数组 nums1 和 nums2,将 nums2 合并到 nums1 中,使得 num1 成为一个有序数组。

    *

    * 说明:

    *

    * 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。

    * 你可以假设 nums1 有足够的空间(空间大小大于或等于 m + n)来保存 nums2 中的元素。

    * 示例:

    *

    * 输入:

    * nums1 = [1,2,3,0,0,0], m = 3

    * nums2 = [2,5,6],       n = 3

    *

    * 输出: [1,2,2,3,5,6]

    *

    * 解题思路:定义一个新数组,定义三个指针分别指向三个数组的第一个元素,比较两个数组的大小,将小的元素放入新数组,当一个数组放入结束后就将另一个全部放入新数组中,最后将新数组的元素赋值给nums1数组

    */

    public class MergeArray {

    public static void main(String[] args) {

    int[] nums1 = {1, 2, 3,0,0,0};

    int[] nums2 = {2, 5, 6};

    merge(nums1, 3, nums2, 3);

    }

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

    int[] newArray = new int[m + n];//定义一个新的数组,长度为两个原数组长度之和

    int i = 0, j = 0, count = 0;//定义三个指针,分别指向三个数组的第一个元素

    //当指针位置小于数组长度时,比较两个数组的元素的大小,小的放入新数组

    while (i < m && j < n) {

    if (nums1[i] < nums2[j]) {

    newArray[count++] = nums1[i++];

    } else {

    newArray[count++] = nums2[j++];

    }

    }

    if (i >= m) {//当第一个数组遍历完成,直接将第二个数组元素放入新数组

    while (j < n) {

    newArray[count++] = nums2[j++];

    }

    }

    if (j <= n) {//当第一个数组遍历完成,直接将第二个数组元素放入新数组

    while (i < m) {

    newArray[count++] = nums1[i++];

    }

    }

    for (int k=0;k

    nums1[k]=newArray[k];

    }

    }

    }

    ---------------------

    作者:小熊维尼446

    来源:CSDN

    原文:https://blog.csdn.net/xxwn446/article/details/88237810

    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • 合并两个有序数组java

    2020-12-06 17:58:32
    给定一只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效。 有效字符串需满足: 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符...

    合并两个有序数组

    给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。

    说明:

    初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
    你可以假设 nums1 有足够的空间(空间大小大于或等于 m + n)来保存 nums2 中的元素。
    示例:

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

    提示:

    -10^9 <= nums1[i], nums2[i] <= 10^9
    nums1.length == m + n
    nums2.length == n

    class Solution {
        public void merge(int[] nums1, int m, int[] nums2, int n) {
            if(m ==0 ) {
                System.arraycopy(nums2,0,nums1,0, n);
            }
            int i1 = m -1;
            int i2 = n -1;
            while(i2>=0){
                if(i1 < 0){
                    System.arraycopy(nums2,0,nums1,0,i2+1);
                    break;
                }
                if(nums1[i1] >= nums2[i2]) {
                    nums1[i1 + i2 +1]=nums1[i1--];
                }else{
                    nums1[i1 + i2 +1]=nums2[i2--];
                }
            
            }        
        }
    }
    
    展开全文
  • 题目描述(简单难度)给两个有序数组,把第二个数组合并到第一个数组中,保持有序。可以注意到第一个数组已经为我们多开辟了第二个数组所需要的空间。解法一 直接法简单粗暴,nums1 作为被插入的数组,然后遍历 nums2...

    题目描述(简单难度)

    9f4f4e8463d84ee696181d6a942acb0a.png

    给两个有序数组,把第二个数组合并到第一个数组中,保持有序。可以注意到第一个数组已经为我们多开辟了第二个数组所需要的空间。

    解法一 直接法

    简单粗暴,nums1 作为被插入的数组,然后遍历 nums2。用两个指针 i 和 j ,i 指向 nums1 当前判断的数字,j 指向 num2 当前遍历的数字。如果 j 指向的数字小于 i 指向的数字,那么就做插入操作。否则的话后移 i ,找到需要插入的位置 。

    1 2 3 0 0 0 | 2 5 6 //当前 j 指向的数字不小于 i 指向的数字,无需插入,后移 i

    ^ ^

    i j

    1 2 3 0 0 0 | 2 5 6 //当前 j 指向的数字不小于 i 指向的数字,无需插入后移 i

    ^ ^

    i j

    1 2 3 0 0 0 | 2 5 6 //当前 j 指向的数字小于 i 指向的数字,将当前数字插入到 nums1 中

    ^ ^

    i j

    1 2 2 3 0 0 | 2 5 6 //插入完成后,j 进行后移,同时由于在 i 前边插入了数字,i 后移回到原来的数字

    ^ ^

    i j

    1 2 2 3 0 0 | 2 5 6 //当前 j 指向的数字不小于 i 指向的数字,无需插入后移 i

    ^ ^

    i j

    1 2 2 3 0 0 | 2 5 6 //由于 nums1 完成遍历,将剩余的 nums2 直接插入

    ^ ^

    i j

    1 2 2 3 5 6 | 2 5 6

    ^ ^

    i j

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

    int i = 0, j = 0;

    //遍历 nums2

    while (j < n) {

    //判断 nums1 是否遍历完

    //(nums1 原有的数和当前已经插入的数相加)和 i 进行比较

    if (i == m + j) {

    //将剩余的 nums2 插入

    while (j < n) {

    nums1[m + j] = nums2[j];

    j++;

    }

    return;

    }

    //判断当前 nums2 是否小于 nums1

    if (nums2[j] < nums1[i]) {

    //nums1 后移数组,空出位置以便插入

    for (int k = m + j; k > i; k--) {

    nums1[k] = nums1[k - 1];

    }

    nums1[i] = nums2[j];

    //i 和 j 后移

    j++;

    i++;

    //当前 nums2 不小于 nums1, i 后移

    }else{

    i++;

    }

    }

    }

    时间复杂度:极端情况下,如果每次都需要插入,那么是 O(n²)。

    空间复杂度:O(1)。

    解法二

    两个有序数组的合并,其实就是归并排序中的一个步骤。回想下,我们当时怎么做的。

    我们当时是新开辟一个和 nums1 + nums2 等大的空间,然后用两个指针遍历 nums1 和 nums2,依次选择小的把它放到新的数组中。

    这道题中,nums1 其实就是我们最后合并好的大数组,但是如果 nums1 当作上述新开辟的空间,那原来的 nums1 的数字放到哪里呢?放到 nums1 的末尾。这样我们就可以完全按照归并排序中的思路了,用三个指针就可以了。

    1 2 3 0 0 0 0 | 2 5 6 7 //将 nums1 的数据放到 nums1 的末尾

    1 2 3 0 1 2 3 | 2 5 6 7 //i 和 j 分别指向两组数据的开头,k 指向代插入位置

    ^ ^ ^

    k i j

    1 2 3 0 1 2 3 | 2 5 6 7 //此时 i 指向的数据小,把它插入,然后 i 后移,k 后移

    ^ ^ ^

    k i j

    1 2 3 0 1 2 3 | 2 5 6 7 //此时 i 指向的数据小,把它插入,然后 i 后移,k 后移

    ^ ^ ^

    k i j

    1 2 3 0 1 2 3 | 2 5 6 7 //此时 j 指向的数据小,把它插入,然后 j 后移,k 后移

    ^ ^ ^

    k i j

    1 2 2 0 1 2 3 | 2 5 6 7 //此时 i 指向的数据小,把它插入,然后 i 后移,k 后移

    ^ ^ ^

    k i j

    1 2 2 3 1 2 3 | 2 5 6 7 //此时 i 遍历完,把 nums2 全部加入

    ^ ^ ^

    k i j

    1 2 2 3 5 6 7 | 2 5 6 7

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

    //将 nums1 的数字全部移动到末尾

    for (int count = 1; count <= m; count++) {

    nums1[m + n - count] = nums1[m - count];

    }

    int i = n; //i 从 n 开始

    int j = 0;

    int k = 0;

    //遍历 nums2

    while (j < n) {

    //如果 nums1 遍历结束,将 nums2 直接加入

    if (i == m + n) {

    while (j < n) {

    nums1[k++] = nums2[j++];

    }

    return;

    }

    //哪个数小就对应的添加哪个数

    if (nums2[j] < nums1[i]) {

    nums1[k] = nums2[j++];

    } else {

    nums1[k] = nums1[i++];

    }

    k++;

    }

    }

    时间复杂度: O(n)。

    空间复杂度:O(1)。

    可以注意到,我们只考虑如果 nums1 遍历结束,将 nums2 直接加入。为什么不考虑如果 nums2 遍历结束,将 nums1 直接加入呢?因为我们最开始的时候已经把 nums1 全部放到了末尾,所以不需要再赋值了。

    解法三

    本以为自己的解法二已经很机智了,直到看到了这里,发现了一个神仙操作。

    解法二中我们的思路是,把 nums1 当作合并后的大数组,依次从两个序列中选较小的数,此外,为了防止 nums1 原有的数字被覆盖,首先先把他放到了末尾。

    那么,我们为什么不从 nums1 的末尾开始,依次选两个序列末尾较大的数插入呢?同样是 3 个指针,只不过变成哪个数大就对应的添加哪个数。

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

    int i = m - 1; //从末尾开始

    int j = n - 1; //从末尾开始

    int k = m + n - 1; //从末尾开始

    while (j >= 0) {

    if (i < 0) {

    while (j >= 0) {

    nums1[k--] = nums2[j--];

    }

    return;

    }

    //哪个数大就对应的添加哪个数。

    if (nums1[i] > nums2[j]) {

    nums1[k--] = nums1[i--];

    } else {

    nums1[k--] = nums2[j--];

    }

    }

    }

    时间复杂度: O(n)。

    空间复杂度:O(1)。

    这道题看起来简单,但用到的思想很经典了。解法二中充分利用已有空间的思想,以及解法三中逆转我们的惯性思维,给定的数组从小到大,然后惯性上习惯从小到大,但如果逆转过来,从大的选,简直是神仙操作了!

    展开全文
  • 88.合并两个有序数组Java 题目描述 给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。 初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间...

    88.合并两个有序数组Java

    题目描述

    给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。

    初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n,这样它就有足够的空间保存来自 nums2 的元素。

    输入输出样式

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

    示例2:
    输入:nums1 = [1], m = 1, nums2 = [], n = 0
    输出:[1]

    本文题来自LeetCode:https://leetcode-cn.com/problems/merge-sorted-array/

    思路

    方法一:直接把nums2的元素添加到nums1中,然后调用排序一次,即可得出两个合并的有序数组。

    方法二:用双指针扫描nums1和nums2,边扫边边比较,并将较小的元素插入新建立的长度为m + n的数组中,然后将新数组赋值给nums1即可。

    方法三:和方法二类似,双指针扫描,但是是逆序扫描,直接把较大者放在nums1的后面,依次往前放,这样就不用开辟新数组。

    算法分析

    1. 时间复杂度为排序所需要的O((m+n)log(m+n)),空间复杂度为O(1)
    2. 时间复杂度为O(m+n),空间复杂度为O(m+n)

    求解函数

    //方法一:插入后调用排序
    public void merge(int[] nums1, int m, int[] nums2, int n) {
            for (int i = 0; i < n; ++i){
                nums1[m + i] = nums2[i];
            }
            Arrays.sort(nums1);
    	}
    
    //方法二:双指针扫描,插入新数组
    public void merge(int[] nums1, int m, int[] nums2, int n) {
            int i = 0, j = 0;
            int[] rst = new int[m + n];
            for (int k = 0; k < m + n; ++k) {
                if (i != m && j != n) {
                    rst[k] = nums1[i] < nums2[j] ? nums1[i++] : nums2[j++];
                }
                else if (i == m){
                    rst[k] = nums2[j++];
                }
                else if (j == n){
                    rst[k] = nums1[i++];
                }
            }
            for (int x = 0; x < m + n; ++x) nums1[x] = rst[x];
        }
        
    
    

    主函数调用

    class Solution88 {
        public static void main(String[] args) {
            int[] nums1 = new int[]{1, 2, 0, 0, 0, 0};
            int[] nums2 = new int[]{1, 3, 4, 5};
            Solution88 sol = new Solution88();
            sol.merge(nums1, 2, nums2, 4);
            for (int i = 0; i < nums1.length; ++i) System.out.print(nums1[i] + ", ");
        }
    
        public void merge(int[] nums1, int m, int[] nums2, int n) {...}
    }
    

    输出结果

    在这里插入图片描述

    展开全文
  • /***写在前面,题目要求的是将有序数组合并,那么有可能这所谓的有序是顺序或者逆序*所以,应该在开始的时候判断一下*然后,在比较的时候应该根据顺序逆序来写判断逻辑*不过常规应该是顺序递增,然后就有了以下的...
  • 对于两个数组[45,56,78,82]和[32,48,72,79,83,85,92]进行合并,使合并数组有序的。即[32,45,48,56,72,78,82,83,85,92] 方法1:类似插入排序 // An highlighted block import java.util.Arrays; class Oneday { ...
  • 给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。 初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n,这样它就有足够的...
  • 两个已经排序的数组A和B,A的数组前M项有值,A的空间足够大足够大能容纳A+B中的所有元素,将B中所有元素插入A中使合并后的数组有序;刚开始接触题就想到暴力解法,先将B加入到A的后面,然后对组合后的数组进行排序,...
  • 最朴素的方法,将nums2数组复制到nums1里面,然后数组排序。 class Solution { public void merge(int[] nums1, int m, int[] nums2, int n) { System.arraycopy(nums2, 0, nums1, m, n); Arrays.sort(nums1); ...
  • class Solution { public void merge(int[] nums1, int m, int[] nums2, int n) { int[] nums3 = new int[m]; for(int i=0; i<m; i++) nums3[i] = nums1[i]; int i=0, j=0, k=0; ...
  • 给定两个有序整数数组 nums1 和 nums2,将 nums2 合并到 nums1 中*,*使得 num1 成为一个有序数组。 说明: 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。 你可以假设 nums1 有足够的空间(空间大小大于或等于 m...
  • /*** java 合并两个有序数组*/public class MergeTwoArray {public static void main(String[] args) {int[] arrayA = {100,200,201,334};int[] arrayB = {101,104,106,233,455,772};int[] arrayC = new int[ar...
  • 88. 合并两个有序数组给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。说明:初始化 nums1 和 nums2的元素数量分别为 m 和 n 。 你可以假设 nums1有足够的空间...
  • /*** 合并两个有序数组* 给定两个有序整数数组 nums1 和 nums2,将 nums2 合并到 nums1 中,使得 num1 成为一个有序数组。* * 说明:* * 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。* 你可以假设 nums1 有足够...
  • 合并两个有序数组问题描述给定两个有序整数数组 nums1 和 nums2,将 nums2 合并到 nums1 中,使得 num1 成为一个有序数组。说明:初始化 nums1 和 nums2 的元素数量分别为 m 和 n。你可以假设 nums1 有足够的空间...
  • 合并两个有序数组Java原址实现)

    千次阅读 2020-07-01 14:43:03
    合并两个有序数组(力扣:88) 给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。
  • 合并两个有序数组为新的有序数组 描述: 合并两个升序排序的整型数组为一个新的升序整型数组并输出。 输入格式: 首先输入第一个数组的数据个数后输入第一个数组按升序排序的数据,然后再输入第二个数组的数据个数,...
  • title: leetcode-88-合并两个有序数组(java) date: 2019-09-19 17:33:55 categories: leetcode tags: leetcode leetcode-88-合并两个有序数组(java) 给定两个有序整数数组 nums1 和 nums2,将 nums2 合并到 ...
  • 合并两个有序数组描述给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。说明:初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。 你可以假设 nums1 有足够的空间...
  • 合并两个升序排序的整型数组为一个新的升序整型数组并输出。 输入格式: 首先输入第一个数组的数据个数后输入第一个数组按升序排序的数据,然后再输入第二个数组的数据个数,最后输入第二个数据按升序排序的数据。...
  • @张九龄合并两个有序数组给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。说明初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 有足够的空间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 604
精华内容 241
关键字:

合并两个有序数组java

java 订阅