精华内容
下载资源
问答
  • 今天小编就为大家分享一篇java实现把两个有序数组合并到一个数组的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 对于两个有序数组arrayM,arrayN,长度分别为m和n;将这两个数组合并成一个数组进行排序,要求时间复杂度为O(m+n); 2. 解题思路: 定义一个数组res,长度为m+n; 定义两个index,分别为indexM、indexN,用来...

    1. 问题描述:

    对于两个有序数组arrayM,arrayN,长度分别为m和n;将这两个数组合并成一个数组并进行排序,要求时间复杂度为O(m+n);

    2. 解题思路:

    1. 定义一个数组res,长度为m+n;
    2. 定义两个index,分别为indexM、indexN,用来记录数组arrayM、arrayN的下标;
    3. 通过分别遍历数组arrayM和arrayN的方式来比较每个值的大小,并将值存放到res中;
    4. 判断indexM和indexN是否分别小于m、n,如果小于则继续执行,否则则表示有一个array遍历结束,需要单独对另一个array操作;
    5. 具体代码如下:
    //定义两个数组下标,遍历并记录index使用;
            int indexM =0;
            int indexN =0;
            int[] arrayM = new int[]{1,4,6,7,8};
            int[] arrayN = new int[]{2,3,5,9,11};
            //定义汇总数组的index;
            int k=0;
            //定义一个汇总数组
            int[] res = new int[arrayM.length+arrayN.length];
    
            //使用while循环遍历;当indexM或者indexN中有任意一个值为M或者N时,则表示当前某一个数组遍历到尾部
            while(indexM<arrayM.length&&indexN<arrayN.length){
                if (arrayM[indexM]<=arrayN[indexN]){
                    res[k]=arrayM[indexM];
                    indexM++;
                }else{
                    res[k]=arrayN[indexN];
                    indexN++;
                }
                k++;
            }
            // 判断哪一个数组被遍历到尾部,则此处将另一个数组添加到汇总数组中即可;
            // 此时 a =indexM,并a++,将M数组中剩余值添加到res中;
            if(indexM!=arrayM.length){
                for(int a = indexM ;a<arrayM.length;a++){
                    res[k]=arrayM[a];
                    k++;
                }
            }else{
                // 此时 a =indexM,并a++,将M数组中剩余值添加到res中;
                for(int a = indexN ;a<arrayN.length;a++){
                    res[k]=arrayN[a];
                    k++;
                }
            }
            for(int a =0;a<k;a++){
               System.out.println(res[a]);
           }
    
    1. 最终输出结果如下:
    1,2,3,4,5,6,7,8,9,11
    

    问题二: 有一个service,该service中有两个synchronize方法,在controller中将该service注入,并在两个线程中执行分别调用这个service的不同方法,问:这两个方法该如何执行?
    解答:这两个方法会顺序执行;
    解释:synchronize为同步锁,该关键字修饰在方法上时表示对该对象加锁(对堆内该对象的地址加锁),且controller中不特殊说明,注入的service是单例的,所以在两个线程中分别调用该对象的不同方法时,只能有一个线程活的对象的锁,即同时只有一个线程可以执行;因此这两个方法虽然同时启动,但是只能顺序执行;

    展开全文
  • 算法两个有序数组合并成一个有序数组 java语言

    万次阅读 多人点赞 2018-06-13 17:10:16
    题目:有两个有序数组a[]和b[],将它们合并成数组c[],需要c[]也是有序数组。 思路:新建一个以两个集合长度之和为长度的新数组,从两数组最左边开始比起,把小的放入新集合,并用变量标记后一位置,  每次比较都是...

    题目:有两个有序数组a[]和b[],将它们合并成数组c[],需要c[]也是有序数组。


    思路:新建一个以两个集合长度之和为长度的新数组,从两数组最左边开始比起,把小的放入新集合,并用变量标记后一位置,

        每次比较都是比较的最左边未比较过的元素(通过变量),循环比较,直至其中有一个集合遍历结束,将另一个集合剩余部分加入新集合中


    public class MyClass {
        public static void main(String[] args) {
            int[] num1 = new int[]{1, 2, 4, 6, 7, 123, 411, 5334, 1414141, 1314141414};
            int[] num2 = new int[]{0, 2, 5, 7, 89, 113, 5623, 6353, 134134};
            //变量用于存储两个集合应该被比较的索引(存入新集合就加一)
            int a = 0;
            int b = 0;
            int[] num3 = new int[num1.length + num2.length];
            for (int i = 0; i < num3.length; i++) {
                if (a < num1.length && b < num2.length) {   //两数组都未遍历完,相互比较后加入
                    if (num1[a] > num2[b]) {
                        num3[i] = num2[b];
                        b++;
                    } else {
                        num3[i] = num1[a];
                        a++;
                    }
                } else if (a < num1.length) {   //num2已经遍历完,无需比较,直接将剩余num1加入
                    num3[i] = num1[a];
                    a++;
                } else if (b < num2.length) {    //num1已经遍历完,无需比较,直接将剩余num2加入
                    num3[i] = num2[b];
                    b++;
                }
            }
            System.out.println("排序后:" + Arrays.toString(num3));
        }
    }


    展开全文
  • 主要介绍了Java实现合并两个有序序列算法,简单描述了序列合并算法的原理与java合并有序序列的具体操作步骤及相关实现技巧,需要的朋友可以参考下
  • /** * */ /** * @author jueying: * @version 创建时间:2018-10-22 下午01:32:44 * 类说明 */ /** ... * 把两个有序数组合并成一个有序数组,实现算法的复杂度为n * * 同理如...
    /**
     * 
     */
    /**   
     * @author jueying:   
     * @version 创建时间:2018-10-22 下午01:32:44   
     * 类说明   
     */
    /**
     * @author jueying
     *
     */
    public class Test4 {
    	
    	/*
    	 * 把两个有序数组合并成一个有序数组,实现算法的复杂度为n
    	 * 
    	 * 同理如果想要数组中的元素只移动一次,原理和字符串中空格代替是一个思想,采用从后面开始复制的算法
    	 * 
    	 * 1.P1指向数组a的最后一个不等于0的元素 P2指向数组b的最后一个元素,P3指向数组a的最后一个元素
    	 * 2.我们默认有序数组都是递增的,并且数组a的空间足够容纳两个数组的合并,分别把P1指向的数和P2指向的数分别做比较,把每次最大的数复制到a中,从右向左依次放置过来
    	 * (1)如果P1指向的数小于P2指向的数,把P2指向的数复制到数组a的末尾,P2,P3向前进一步
    	 * (2)如果P1指向的数大于P2指向的数,把P1指向的数复制到a的末尾,P1,P3向前一步
    	 * (3)如果P1指向的数等于P2指向的数,那么把P1和P2的数依次复制到a的末尾,P1和P1依次向前一步,P3向前两步
    	*/
    	public static void fun(int a[],int b[],int P1,int P2,int P3){
    		
    		for(int i=9;i>=0;i--){
    			
    			    	   if(P1>=0&&P2>=0&&a[P1]>b[P2]){
    							if(P1>=0&&P1<=4&&P3>=0&&P3<=9){
    								a[P3]=a[P1];
    								--P1;//向前一步
    								--P3;//P3向前一步
    							}
    							
    						}else if(P1>=0&&P2>=0&&a[P1]<b[P2]){
    							if(P3>=0&&P3<=9&&P2>=0&&P2<=4){
    								a[P3]=b[P2];
    								--P2;
    								--P3;
    							}
    							
    						}else if(P1>=0&&P2>=0&&a[P1]==b[P2]){//如果P1和P2指向的数相等时,那么P1和P2都向前一步,P3向前两步
    							a[P3]=a[P1];
    							--P3;
    							a[P3]=a[P2];
    							--P3;
    							--P1;
    							--P2;
    						}else  if(P1<0&&P2>=0){//P1已经遍历完数组a了,P2还没有遍历完数组b,这时候把b中的剩下没有遍历的数据依次添加到a中
    					    	   a[P3]=b[P2];
    					    	   --P3;
    					    	   --P2;
    						}else if(P2<0&&P1>=0){//P2已经遍历完数组b了,P1还没有遍历完数组a,这时候把a中剩下没有遍历的数据依次添加到a中
    					    	   a[P3]=b[P1];
    					    	   --P3;
    					    	   --P1;
    					       }
    					System.out.println("此时P1的值是"+P1+" P2的值是:"+P2);
    				
    		}
    		System.out.println("合并后的数组是:");
    		for(int i=0;i<a.length;i++){
    			System.out.print(a[i]+" ");
    		}
    		System.exit(0);
    	}
    	
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    		int a[]={2,10,15,17,18,0,0,0,0,0};
    		int b[]={0,3,12,16,19};
    		Test4.fun(a,b,4,4,9);
    
    	}
    
    }
    

    展开全文
  • 两个升序数组合并成一个有序数组

    千次阅读 2020-04-23 01:30:35
    题:两个升序数组合并成一个升序数组。 利用题中数组是生序排列的。代码如下:代码中去除了相同元素 @Test public void test() { // 定义两个数组 a ,b 生序排列 int[] a = {1, 3, 11, 34, 444, 555, 9999}; ...

    题:两个升序数组合并成一个升序数组。

    • 利用题中数组是生序排列的。代码如下:代码中去除了相同元素
    @Test
        public void test() {
            // 定义两个数组 a ,b  生序排列
            int[] a = {1, 3, 11, 34, 444, 555, 9999};
            int[] b = {20, 22, 55, 800, 10000, 22222};
            // 定义新的存储空间
            List<Integer> resultList = new ArrayList<Integer>();
            // 利用数组本身就是生序排列的 ,只需要比较每个数组最小的值,将小的加入新的空间,然后小的角标+1,依次循环。
            int i = 0;
            int j = 0;
            while (i < a.length && j < b.length) {
                if (a[i] < b[j]) {
                    // 小的添加到新开辟的空间 然后 i++
                    resultList.add(a[i++]);
                } else if (a[i] > b[j]) {
                    // 小的添加到新开辟的空间 然后 j++
                    resultList.add(b[j++]);
                } else {
                    // 如果相同添加进去一个
                    resultList.add(a[i]);
                    i++;
                    j++;
                }
            }
            // 因为原数组是生序排列,如果两个数组长度不同那么必定会有一个数组没有添加完
            while (i < a.length) {
                resultList.add(a[i++]);
            }
            while (j < b.length) {
                resultList.add(b[j++]);
            }
            System.out.println(resultList);
        }
    

    最终结果如下:

    [1, 3, 11, 20, 22, 34, 55, 444, 555, 800, 9999, 10000, 22222]
    
    展开全文
  • java实现-合并两个有序数组

    千次阅读 2021-02-07 11:10:05
    给你两个有序整数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。 初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n,这样它就有足够的...
  • 两个有序数组,合并成另一个有序的数组,升序。将两个有序数组,合并成另一个有序的数组,升序。将两个有序数组,合并成另一个有序的数组,升序
  • java) 问题描述:设X[ 0 : n - 1]和Y[ 0 : n – 1 ]为两个数组,每个数组中含有n个已排好序的。找出X和Y的2n个的中位。 利用分治策略试设计一个O (log n)时间的算法求出这2n个的中位
  • 给定两个有序整数组 nums1 和 nums2,将 nums2 合并到 nums1 中,使得 num1 成为一个有序数组。 说明: 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。 你可以假设 nums1 有足够的空间(空间大小大于或等于 m + ...
  • 两个有序数组合并成一个有序数组

    万次阅读 2016-09-23 11:10:04
    百度2012实习生校园招聘笔试题 数组al[0,mid-1]和al[mid,num-1]是各自有序的,对数组al[0,num-1...1、用temp数组作为中间变量,保存两个有序子数组的合并结果数组,再复制回原数组。  空间复杂度O(N),时间复杂度O(m
  • 搜了好多文章,发现代码是错的,没有达到去重...题目要求:数组A,B有序,要求合并A,B,并且去除重复元素。 下面代码实现的复杂度,设A和B的数组长度为M和N那么时间复杂度为O(M+N),如果中用数组实现,空间复杂度也...
  • 问题分析:本题要求利用原有的单链表LA,LB中的结点来产生一新的链表LA,新的单链表首先以LA的头结点为头结点构成一空表,然后用尾插法将LA LB中的各结点按从小到大顺序插入到新形成的链表中。 插入过程中引入3...
  • 问题描述:现有两个升序的整数组,设计算法实现两个升序整数数组的合并。要求合并完成的数组为升序。 要求:预定义数组为升序 补充:这里考虑到最后的结果数组可能出现数组元素重复,合并后元素重复的问题,采用...
  • Java合并两个有序序列算法实现

    千次阅读 2015-06-25 16:27:48
    Java合并两个有序序列算法实现问题描述输入:序列A,a1,a2,...aq,aq+1,aq+2,...,ar>A,a_1,a_2,...a_q,a_{q+1},a_{q+2},...,a_{r}>,其中a0,aq+1,a_{q+1} 输出:序列B,b1,...,br>,
  • 一个简单的有序数组合并算法:写一个函数,传入 2 个有序的整数数组,返回一个有序的整数数组。实现相当简单,创建一个长度为这两个长度之和的数组,然后分别用三个指针指向这三个数组,找到这两个数组中各个元素在...
  • 给你一个按递增排序的整数组,需要找到数组中的两个整数,他们的和等于给定的目标值,然后返回它们的下标。题目假设给你的数组总是有且只有一个解,而且同一个元素不能使用两次,另外返回的下标要从1开始。 如果找...
  • 请你找出这两个有序数组的中位,并且要求算法的时间复杂度为 O(log(m + n))。 你可以假设 nums1 和 nums2 不会同时为空。 示例 1: nums1 = [1, 3] nums2 = [2] 则中位是 2.0 示例 2: nums1 = [1, 2] ...
  • 两个有序数组合并为一个有序数组

    千次阅读 2012-02-23 17:37:23
    两个有序数组合并为一个有序数组 突然想到了这个算法,记得以前看过,但是没写,怕自己会写不出这个算法,于是就把它用JAVA写出来,呵呵。   思想:先依次比较两个数组,按照小的就传入新 class ArraySort { ...
  • 两个有序单链表,要求合并后依然有序。 时间复杂度O(m+n),m和n分别是两个链表的长度。 public class MergeTwoList { /** * 循环 * @param n1 * @param n2 * @return */ public static Node ...
  • 合并两个有序数组(Java原址实现)

    万次阅读 2020-07-01 14:43:03
    合并两个有序数组(力扣:88) 给你两个有序整数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。
  • 题目:有两个有序数组a,b,现需要将其合并成一个新的有序数组。 简单的思路就是先放到一个新的数组中,再排序。但是这样的没体现任何算法,这里考的不是快速排序等排序算法。关键应该是如何利用 有序 已知这个条件...
  • 合并两个已经排序的数组为另一个数组算法,详细介绍并用代码实现,望对大家有帮助!
  • java实现两个有序单链表合并

    万次阅读 多人点赞 2018-11-19 13:55:30
    本次分享的事两个有序单链表的合并, 遍历方法 递归 非递归 节点类 /** * @auther: lawt * @date: 2018/11/4 08 * @Description: 结点信息 */ public class Node { /** * 为了方便,这两个变量...
  • 组合算法Java实现

    千次阅读 2018-04-01 21:55:11
     * 组合算法java实现  * 方法:DFS  * 思路:  * 给定一数组input,长度为N,现要从中选取r元素,记其在num中下标为a1,a2.....ar  * 1.选取第一元素num[a1],则下一元素的可选下标范围为[a1+1,N]  * 2....
  • import java.util.*;public class Main { public static void main(String[] args) { List&lt;List&lt;Integer&gt;&gt; lists = new ArrayList&lt;&gt;(); List&lt;Integer&gt;...
  • 算法实现之合并两个有序链表

    千次阅读 2019-03-04 13:19:23
    两个有序链表合并为一个新的有序链表返回。新链表是通过拼接给定的两个链表的所有节点组成的。
  • 昨天面试,问了一个简单的算法题,... 思路:先分别对两个数组进行排序(可以用快速排序),然后两路归并。 #include using namespace std; class Solution { public: int *sort(int *a,int lenA,int *b,int le

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 105,410
精华内容 42,164
关键字:

java算法两个有序数组合并

java 订阅