精华内容
下载资源
问答
  • 两个有序数组合并成一个有序数组

    千次阅读 2015-08-19 22:37:46
    思想:先依次比较两个数组,按照小的就传入新的数组。当这次比较完之后可能有一个数组的长度很长,留下一些数组,然后在新数组的末尾插入即可。 代码: public class ArraySort { public static void main...
    思想:先依次比较两个数组,按照小的就传入新的数组。当这次比较完之后可能有一个数组的长度很长,留下一些数组,然后在新数组的末尾插入即可。

    代码:
    public class ArraySort {  
      
        public static void main(String[] args) {  
            int[] a = {1,3,4};  
            int[] b = {2,3,5,6};  
              
            int[] c = mergeArray(a, b);  
              
            for(int n : c){  
                System.out.print(n+" ");  
            }  
        }  
          
        //合并数组  
        public static int[] mergeArray(int[] a , int[] b){  
            int result[] = new int[a.length + b.length];  
              
            if(checkSort(a) && checkSort(b)){  
                //说明ab数组都是有序的数组  
                //定义两个游标  
                int i=0,j=0,k=0;  
                  
                while(i<a.length && j<b.length){  
                    if(a[i] <= b[j]){  
                        result[k++] = a[i++];  
                    }else{  
                        result[k++] = b[j++];  
                    }  
                }  
                  
                while(i < a.length){  
                    //说明a数组还有剩余  
                    result[k++] = a[i++];  
                }  
                  
                while(j < b.length){  
                    result[k++] = b[j++];  
                }  
            }  
              
            return result;  
              
        }  
          
        //检查一个数组是否是有序的  
          
        // 1 2 3  
        public static boolean checkSort(int[] a){  
            boolean flag = false;//默认不是有序的  
              
            for(int i=0;i<a.length-1;i++){  
                if(a[i] > a[i+1]){  
                    //说明不是有序的  
                    flag = false;  
                    break;  
                }else{  
                    flag = true;  
                }  
            }  
              
            return flag;  
        }  
    }  


    归并排序

    归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。值得注意的是归并排序是一种稳定的排序方法。速度仅次于快速排序,为稳定排序算法,一般用于对总体无序,但是各子项相对有序的数列

        public class MergingSort {  
          
            public static void sort(int[] data, int left, int right) {  
                if (left < right) {  
                    // 首先找出中间的索引  
                    int center = (left + right) / 2;  
          
                    // 对中间索引左边的数组进行递归  
                    sort(data, left, center);  
          
                    // 对中间索引右边的数组进行递归  
                    sort(data, center + 1, right);  
                    // 合并  
                    merge(data, left, center, right);  
                }  
            }  
          
            public static void merge(int[] data, int left, int center, int right) {  
          
                int[] tmpArr = new int[data.length];  
          
                int mid = center + 1;  
          
                // third记录中间数组的索引  
                int third = left;  
          
                int tmp = left;  
          
                while (left <= center && mid <= right) {  
                    // 将两个数组中取出最小的数放入中间数组  
                    if (data[left] <= data[mid]) {  
                        tmpArr[third++] = data[left++];  
                    } else {  
                        tmpArr[third++] = data[mid++];  
                    }  
                }  
          
                // 剩余部分依次放入中间数组  
                while (mid <= right) {  
                    tmpArr[third++] = data[mid++];  
                }  
          
                while (left <= center) {  
                    tmpArr[third++] = data[left++];  
                }  
                  
                while(tmp <= right){  
                    data[tmp] = tmpArr[tmp++];  
                }  
            }  
          
            public static void main(String[] args) {  
                int[] a = { 3, 2, 5, 4 };  
                  
                sort(a, 0, a.length - 1);  
          
                for (int i = 0; i < a.length; i++) {  
                    System.out.print(a[i] + " ");  
                }  
            }  
        }  



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

    千次阅读 2015-12-11 18:16:22
    两个有序且有重复的数组,合并为一个无重复的有序数组 比如a={1,1,1,2,2,4,8,9,17,18,19,25,30,35};b={3,6,6,9,10,15,16,19,25}; 合并结果为c={1, 2, 3, 4, 6, 8, 9, 10, 15, 16, 17, 18, 19, 25, 30, 35}; ...

    两个有序且有重复的数组,合并为一个无重复的有序数组

    比如a={1,1,1,2,2,4,8,9,17,18,19,25,30,35};b={3,6,6,9,10,15,16,19,25};

    合并结果为c={1, 2, 3, 4, 6, 8, 9, 10, 15, 16, 17, 18, 19, 25, 30, 35};


    算法代码为:

    	
    	List<Integer> mergeList(int[] a, int[] b){
    		List<Integer> result=new ArrayList<Integer>();
    		int i = 0,j = 0;
    		while(i<a.length&&j<b.length){
    			if(i!=a.length-1 && a[i]==a[i+1]){
    				i++; 
    				continue;
    			}
    			if(j!=b.length-1 && b[j]==b[j+1]){
    				j++; 
    				continue;
    			}
    			if(a[i]>b[j]){
    				result.add(b[j++]);
    			}else if(a[i]<b[j]){
    				result.add(a[i++]);
    			}else if(a[i]==b[j]){
    				result.add(a[i]);
    				i++;
    				j++;
    			}
    		}
    		while(i<a.length){
    			result.add(a[i++]);
    		}
    		while(j<b.length){
    			result.add(b[j++]);
    		}
    		return result; 
    	}
    测试代码为:

    <pre name="code" class="html">	
    	void testMergeList(){
    		int a[]={1,1,1,2,2,4,8,9,17,18,19,25,30,35};
    		int b[]={3,6,6,9,10,15,16,19,25};
    		List<Integer> c = mergeList(a,b);
    		System.out.println("xuejiao c = "+c);
    		//Log.d("xuejiao","xuejiao c = "+c);
    	}


     
    

    展开全文
  • 将这两个数组合并成一个数组并进行排序,要求时间复杂度为O(m+n); 2. 解题思路: 定义一个数组res,长度为m+n; 定义两个index,分别为indexM、indexN,用来记录数组arrayM、arrayN的下标; 通过分别遍历数组...

    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是单例的,所以在两个线程中分别调用该对象的不同方法时,只能有一个线程活的对象的锁,即同时只有一个线程可以执行;因此这两个方法虽然同时启动,但是只能顺序执行;

    展开全文
  • let sortArr = (arr1,arr2) =>{ let [i,j] = [0,0] let newArr = [] while(i<arr1.length&& j < arr2.length) { if (arr1[i]<arr2[j]) { newArr.push(arr1[i]) ......

    let sortArr = (arr1,arr2) =>{

        let [i,j] = [0,0]

        let newArr = []

        while(i<arr1.length&& j < arr2.length) {

           if (arr1[i]<arr2[j]) {

            newArr.push(arr1[i])

            i++

          }  else if (arr1[i]>arr2[j]) {

            newArr.push(arr2[j])

            j++

          } else {

           newArr.push(arr1[i])

           newArr.push(arr2[j])

           i++,j++

         }

       }

       return newArr

    }

    展开全文
  • 昨天面试,问了一个简单的算法题,... 思路:先分别对两个数组进行排序(可以用快速排序),然后两路归并。 #include using namespace std; class Solution { public: int *sort(int *a,int lenA,int *b,int le
  • function arrSort(arr1, arr2) { var [i,j] = [0,0]; let newArr = []; while(i < arr1.length || j <arr2.length) { if (arr1[i] < arr2[j]) { newArr.push(arr1[i]); ...
  • 假设有这样一个需求,一个数组的子元素全是有序数组,类似: let arr= [[1, 2], [0, 3, 4,4,4,6,7,8,9,10], ...我们希望将上述数组合并一个有序数组,怎么处理呢? 最简单的方案就是:将数组整体合并,然后sort排...
  • 个人刚面试遇到的面试题,回来后,总结的
  • 下面有两段相似的代码,第段除了返回合并后的有序数组还将这两个有序数组清空了,该算法的思路是始终比较两个数组的首元素大小,然后将小者 shift 出来 push 到结果数组中去,因为总是会将数组首元素较小的那个...
  • 合并两个有序数组一个有序数组

    千次阅读 2016-07-06 21:49:44
    两个有序数组,合并成一个有序数组,假设第一个数组空间足够容纳两个数组。 分析: 考虑到a数组很大,可以直接在a数组上进行合并,但是要讲究效率。如果单纯从前往后合并,那么效率会非常低,因为a数组后面的数字...
  • 思路:将两个数组排序,然后判断数组长度,长度为单数,则取二分之处的,否则取二分之处和二分之处的之和除以2. var findMedianSortedArrays = function(nums1, nums2) { var arr = merge(nums1,nums...
  • 请你找出这两个有序数组的中位,并且要求算法的时间复杂度为 O(log(m + n))。 你可以假设 nums1 和 nums2 不会同时为空。 示例 1: nums1 = [1, 3] nums2 = [2] 则中位是 2.0 示例 2: nums1 = [1, 2] nums2 = [3,...
  • 请你找出这两个有序数组的中位,并且要求算法的时间复杂度为O(log(m + n))。 你可以假设nums1和nums2不会同时为空。 示例 1: nums1 = [1, 3] nums2 = [2] 则中位是 2.0示例 2: nums1 = [1, 2] nums2 = [3, ...
  • (JS)寻找两个有序数组的中位

    万次阅读 2020-04-18 13:44:33
    寻找两个有序数组的中位 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。 请你找出这两个有序数组的中位,并且要求算法的时间复杂度为 O(log(m + n))。 你可以假设 nums1 和 nums2 不会同时为空。 /** * @...
  • 请你找出这两个有序数组的中位,并且要求算法的时间复杂度为 O(log(m + n))。 你可以假设 nums1 和 nums2 不会同时为空。 示例1: nums1 = [1, 3] nums2 = [2] 则中位是 2.0 示例2: nums1 = [1, 2] nums2 = ...
  • 给定两个有序整数组 nums1 和 nums2,将 nums2 合并到 nums1 中,使得 num1 成为一个有序数组。 说明: 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。 你可以假设 nums1 有足够的空间...
  • 寻找两个有序数组的中位 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。 你可以假设 nums1 和 nums2 不会同时为空。 输入 输出 nums1 = [1, 3] ,nums2 = [2] 2.0 nums1 = [1, 2] ,nums2 = [3, 4]...
  • 给定两个有序整数组nums1和nums2,将nums2合并到nums1中,使得num1成为一个有序数组。 说明: 初始化nums1和nums2的元素数量分别为m和n。 你可以假设nums1有足够的空间(空间大小大于或等于m + n)来保存nums2中...
  • js 合并两个有序数组

    2020-06-04 16:15:57
    给你两个有序整数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。 说明: 初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。 你可以假设 nums1 有足够的空间(空间大小大于或等于 ...
  • 给定两个有序整数组 nums1 和 nums2,将 nums2 合并到 nums1 中,使得 num1 成为一个有序数组。说明:初始化 nums1 和 nums2 的元素数量分别为 m 和 n。你可以假设 nums1 有足够的空间(空间大小...
  • js代码-有序数组在保持数组有序的情况下插入数字。 种实现方式
  • 剑指offer2.3.2字符串:有两个排序的数组A1和A2,内存在A1的末尾有足够多的空余空间容纳A2,编写一个函数,将A2合并到A1排序。解析:从尾到头比较两个数组中的数字,把较大的赋值到空间大的数组的合适位置。#...
  • 寻找两个有序数组的中位 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。 请你找出这两个有序数组的中位,并且要求算法的时间复杂度为 O(log(m + n))。 你可以假设 nums1 和 ...
  • js代码-合并两个有序数组

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,964
精华内容 11,185
关键字:

js两个有序数组合并成一个有序数组