精华内容
下载资源
问答
  • 给定两个有序数组a b 使合并后的数组仍然有序 归并算法的事件复杂度为O logn
  • 合并两个有序数组归并排序

    千次阅读 2017-03-16 19:10:51
    package com.zyt.interview;public class MergeSortArray { public static int[] sort(int[] a,int[] b){//a,b数组必须有序 int merge[]=new int[a.length+b.length]; int lenA=0,lenB=0,lenMer=0;
    package com.zyt.interview;
    
    public class MergeSortArray {
    
        public static int[] sort(int[] a,int[] b){//a,b数组必须有序
            int merge[]=new int[a.length+b.length];
    
            int lenA=0,lenB=0,lenMer=0;
    
            while(lenA<a.length&&lenB<b.length){
                if(a[lenA]<b[lenB]){
                    merge[lenMer++]=a[lenA++];
                }else{
                    merge[lenMer++]=b[lenB++];
                }
            }
            while(lenA<a.length){
                merge[lenMer++]=a[lenA++];
            }
    
            while(lenB<b.length){
                merge[lenMer++]=b[lenB++];
            }
    
            return merge;
        }
    
        public static void main(String[] args) {
            int[] a={1,2,3,3,4,5};
            int[] b={7,8,8,9};
            int[] c=MergeSortArray.sort(a, b);
            for (int i : c) {
                System.out.print(i);
                System.out.print(" ");
            }
    
        }
    
    }
    展开全文
  • #include #include #include #include #include #define ERROR -22 static int merge(int *a, int m, int *b, int n, int *c) ... int i = 0, j = 0, k = 0;...归并排序,实际上就是一先分后合在一起的思想
    #include<stdio.h>
    #include<math.h>
    #include<stdlib.h>
    #include<string.h>
    #include<error.h>
    
    #define ERROR	-22
    
    static int merge(int *a, int m, int *b, int n, int *c)
    {
    	int i = 0, j = 0, k = 0;
    	if(a==NULL||b==NULL||c==NULL){
    		fprintf(stderr, "arr should not be NULL\n");
    		return ERROR;
    	}
    	
    	if(m==0||n==0){
    		fprintf(stderr, "num should not be zero\n");
    		return ERROR;
    	}
    	
    	while(i<m&&j<n){
    		if(a[i]<b[j]){
    			c[k++] = a[i++];
    		}else{
    			c[k++] = b[j++];
    		}
    	}
    	
    	while(i<m){
    		c[k++] = a[i++];
    	}
    	while(j<n){
    		c[k++] = b[j++];
    	}
    	return 0;
    }
    int main()
    {
    	int a[] = {4,7, 9, 20};
    	int b[] = {5, 6};
    	int m = sizeof(a)/sizeof(a[0]);
    	int n = sizeof(b)/sizeof(b[0]);
    	int c[m+n];
    	if(merge(a, m, b, n, c)<0){
    		return ERROR;
    	}
    	int i = 0;
    	for(i=0; i<m+n; i++){
    		printf("%d\t", c[i]);
    	}
    	printf("\n");
    	return 0;
    }

    归并排序,实际上就是一个先分后合在一起的思想

    展开全文
  • @归并排序C++代码实现(将两个有序数组元素依次比较合并为一个新的有序数组) 归并排序分为两个大的步骤,分为划分和归并。归并是将两个有序数组分别为数组A和数组B合并成为一个有序数组,首先取数组A和数组B的第一...

    @归并排序C++代码实现(将两个有序数组元素依次比较合并为一个新的有序数组)

    归并排序分为两个大的步骤,分为划分和归并。归并是将两个有序数组分别为数组A和数组B合并成为一个有序数组,首先取数组A和数组B的第一个元素进行比较,将其中较小的元素放入新的数组中,然后再取出较小元素数组中的下一个元素与另一个数组中的第一个元素进行比较,依然将两者较小的元素放入新的数组中,如此迭代下去,直到将两个数组合并完毕。

    划分的话是将划分为多个数组,两两进行归并。最初的是将数组划分为由每一个元素组成的数组,然后两两归并为一个含有两个元素的数组,依次迭代归并为含有四个、八个……元素的数组,直至所有元素归并为一个有序的数组。

    方法一:python标准方法(不需要额外的列表空间)

    # 标准方法:归并排序
    # 该算法的优点就是不用额外的空间,只是在当前的列表中处理
    import sys
    
    def merge(left, right):
        i,j = 0, 0
        result = []
        while i < len(left) and j < len(right):
            if left[i] <= right[j]:
                result.append(left[i])
                i += 1
            else:
                result.append(right[j])
                j += 1
        result += left[i:]
        result += right[j:]
        return result
    
    def Merge_sort(lists):
        if len(lists) <= 1:
            return lists
        num = len(lists)//2
        left = Merge_sort(lists[:num])
        right = Merge_sort(lists[num:])
        return merge(left, right)
    
    
    if __name__ == '__main__':
        lines = sys.stdin.readlines()
        lists = lines[0].strip().split()
        print("排序前序列为:", )
        for i in lists:
            print(i, end=" ")
        print("\n排序后结果为:")
        for i in (Merge_sort(lists)):
            print(i, end=" ")
    
    

    方法二:C++标准方法(不需要额外的列表空间)

    #include <iostream>
    using namespace std;
    
    void Merge(int *initList, int *mergedList, const int l, const int m, const int n);
    void MergePass(int *initList, int *resultList, const int n, const int s);
    void MergeSort(int *a, int n);
    
    int main()
    {
    	//int a[] = {0,23,47,81,95,7,14,39,55,62,74};
    	//for (int k=0;k<11;k++)
    	//{
    	//	cout << a[k] << " ";
    	//}
    	//cout << endl;
    	//int b[11] ={0};
    	//Merge(a,b,1,4,10);
    	//for (int k=0;k<11;k++)
    	//{
    	//	cout << b[k] << " ";
    	//}
    	//cout << endl;
    
    
    	//int m[] = {0,26,5,77,1,61,11,59,15,48,19};
    	//int n[11] = {0};
    	//for (int k=0;k<11;k++)
    	//{
    	//	cout << m[k] << " ";
    	//}
    	//cout << endl;
    	//
    	//MergePass(m,n,10,1);
    	//for (int k=0;k<11;k++)
    	//{
    	//	cout << n[k] << " ";
    	//}
    	//cout << endl;
    
    	//MergePass(n,m,10,2);
    	//for (int k=0;k<11;k++)
    	//{
    	//	cout << m[k] << " ";
    	//}
    	//cout << endl;
    
    	//MergePass(m,n,10,4);
    	//for (int k=0;k<11;k++)
    	//{
    	//	cout << n[k] << " ";
    	//}
    	//cout << endl;
    
    	//MergePass(n,m,10,8);
    	//for (int k=0;k<11;k++)
    	//{
    	//	cout << m[k] << " ";
    	//}
    	//cout << endl;
    
    	
    	//声明一个数组,并打印出所有的数组元素
    	int x[] = {0,26,5,77,1,61,11,59,15,48,19};
    	for (int k=0;k<11;k++)
    	{
    		cout << x[k] << " ";
    	}
    	cout << endl;
    	//将该数组进行归并排序,然后打印出数组中的所有值
    	MergeSort(x,10);
    	for (int k=0;k<11;k++)
    	{
    		cout << x[k] << " ";
    	}
    	cout << endl;
    	
    	system("pause");
    	return 0;
    }
    
    
    void Merge(int *initList, int *mergedList, const int k, const int m, const int n)
    {
    	int i,j,iresult;
    	for(i =k,j = m+1,iresult= k;i<=m && j <=n; iresult++)
    	{
    		//两个数组中的取出的元素哪个小哪个就放到新的有序数组中
    		if (initList[i] <= initList[j])
    		{
    			mergedList[iresult] = initList[i];
    			i++;
    		} 
    		else
    		{
    			mergedList[iresult] = initList[j];
    			j++;
    		}
    	}
    	copy(initList+i,initList+m+1,mergedList+iresult);   //把initList中从下标i开始,到下标m+1之前的所有元素拷贝到mergedList中下标从iresult开始的数组中
    	copy(initList+j,initList+n+1,mergedList+iresult);	//把initList中从下标j开始,到下标n+1之前的所有元素拷贝到mergedList中下标从iresult开始的数组中
    }
    
    
    void MergePass(int *initList, int *resultList, const int n, const int s)
    {
    	int i;
    	for (i =1;i<=n-2*s+1;i+=2*s)
    	{
    		Merge(initList,resultList,i,i+s-1,i+2*s-1);
    	}
    	if ((i+s-1)<n)
    	{
    		Merge(initList,resultList,i,i+s-1,n);
    	} 
    	else
    	{
    		copy(initList+i,initList+n+1,resultList+i);
    	}
    }
    
    
    void MergeSort(int *a, int n)
    {
    	int *tempList = new int [n+1];
    	for (int i = 1;i<n;i*=2)
    	{
    		MergePass(a,tempList,n,i);
    		i*=2;
    		MergePass(tempList,a,n,i);
    	}
    	delete []tempList;
    	tempList = NULL;
    }
    
    展开全文
  • 顺带个合并两个有序数组。 先来合并两个有序数组 #include<iostream> #include<vector> vector<int> mergeTwoArray(vector<int> arr1, vector<int> arr2) { if(arr1.size()==0 &...

    今天写个简简单单的归并排序。顺带个合并两个有序数组。

    先来合并两个有序数组

    #include<iostream>
    #include<vector>
    
    vector<int> mergeTwoArray(vector<int> arr1, vector<int> arr2)
    {
    	if(arr1.size()==0 && arr2.size()==0) 	//判断入参是否为空
    	{
    		return;
    	}
    	if(arr1.size()==0)				//arr1为空的话,直接返回arr2
    		return arr2;
    	if(arr2.size()==0)
    		return arr1;
    		
    	vector<int> arr;		//定义一个存放结果的容器
    	int i=0,j=0;
    	while(i<arr1.size() && j<<arr2.size())		//遍历两个vector的共同长度
    	{
    		if(arr1[i] <= arr2[j])					
    		{
    			arr.push_back(arr1[i]);
    			i++;
    		}
    		else
    		{
    			arr.push_back(arr2[j]);
    			j++;
    		}
    	}
    	if(i==arr1.size())							//a==arr1.size()说明arr1已经走到了末尾。直接追加arr2容器到最终的结果容器中即可
    	{
    		while(j < arr2.size())
    		{
    			arr.push_back(arr2[j]);
    			j++;
    		}
    	}
    	else
    	{
    		while(i < arr1.size())
    		{
    			arr.push_back(arr1[i]);
    			i++;
    		}
    	}
    	
    	return arr;
    }
    
    
    

    前面的博客中有其他排序,接下来。对某个数组进行归并排序,直接上代码说

    #include<iostream>
    #include<vector>
    
    void mergeSort(vector<int> arr)
    {
    	//第一步肯定还是做入参判断啦
    	if(arr.size() == 0)
    	{
    		return;
    	}
    	if(arr.size() == 1)
    	{
    		return arr;
    	}
    		
    	const length = arr.size();
    	int mid = length / 2;
    
    	vector<int> arr1(arr.begin(), arr.begin()+mid);		//左半边构建一个vector
    	vector<int> arr2(arr.begin()+mid, arr.end());		//右半边构建一个vector
    
    	//注意:先执行括号里面的mergeSort函数,当然,这里是递归调用。
    	//直至拿到返回值(都只含有一个元素)vector时再调用,最上面函数块的mergeTwoArray方法
    	return mergeTwoArray(mergeSort(arr1), mergeSort(arr2));		
    }
    
    
    
    展开全文
  • 合并有序数组归并排序

    千次阅读 2020-02-06 15:55:07
    合并有序数组 题:给定两个排序后的数组A和数组B,其中A的末端有足够的缓冲空间容纳B,编写一个方法,将B合并到A并排序 思路:参照归并排序 对A数组进行从后往前进行填充 A和B数组两两比较,大的数填到A中 public...
  • 设有两个有序数组 arr1 与 arr2,数组长度分别为 m 与 n, 要合并成一个长度位 m+n 的有序数组 arr3. 最差情况下:比较次数为 m+n-1 此时,将数组 arr1 与数组 arr2 中的元素两两比较,将值小的放进数组 arr3, ...
  • 今天来学习归并排序算法。 归并算法的核心思想是分而治之,就是将大问题转化为小问题,在解决小问题的基础上,再去解决大问题。讲这句话套用到排序中,就是将一大的待排序区间分为小的待排序区间,对小的排序区间...
  • 搜了好多文章,发现代码是错的,没有达到去重...题目要求:数组A,B有序,要求合并A,B,并且去除重复元素。 下面代码实现的复杂度,设A和B的数组长度为M和N那么时间复杂度为O(M+N),如果中用数组实现,空间复杂度也...
  • 归并排序说明算法逻辑图示说明合并两个有序数组,合并之后仍然有序一个数组的有序部分合并为完整有序归并排序归并排序执行过程分析算法分析 归并排序说明 归并排序,简单理解就是先归再并,在归的时候,我们使用递归...
  • 请你找出这两个有序数组的中位数,并且要求算法的时间复杂度为 O(log(m + n))。你可以假设 nums1 和 nums2 不会同时为空。 示例 1 :nums1 = [1, 3] nums2 = [2] 则中位数是 2.0 示例 2: nums1 = [1, 2] nums2 = ...
  • 题目:有两个排序的数组A1和A2,内存在A1的末尾有足够的空余空间容纳A2。请写一个函数,把A2的所有数字插入A1中,并且所有的数字是排序的。 题目上的条件是内存在A1的末尾有足够的空余空间容纳A2。所以跟归并排序还...
  • 归并排序是将两个排好序的数组合并到一个新的数组中去, 而此题是将后一个小数组归并到前面一个大数组中去,仅此差异。 void merge(int *nums1, int nums1Size, int m, int *nums2, int nums2Size, int n) { //...
  • 问题描述:将两个有序数组归并为一个有序的新数组 编译环境:vc++6.0 代码: #include <stdio.h> /*将两个有序数组归并为一个有序的新数组*/ int main() { int i = 0, j = 0, k = 0; int a[5] = {...
  • 归并排序就这么简单

    2021-02-25 19:55:46
    归并排序就这么简单从前面已经讲解了冒泡排序、...归并排序的介绍来源百度百科:归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一非常典型的应用。将已...
  • 【问题描述】 编写一个程序,将两个元素从小到大有序的一维数组归并成一个有序的一维数组...程序将两个有序一维数组合并为一个有序数组并按照从小到大顺序输出。每个元素输出时用空格分隔,最后一个输出之后没有空格。
  • 两个有序数组合并为一个,给出A=[1,2,3,4],B=[2,4,5,6],返回 [1,2,2,3,4,4,5,6]。 解题思路:从头开始比较两个数列中的数,哪一个小就取出依次存入新的数组中,直到其中一个全部比较完,将另一个数组剩下的部分...
  • 本文实例为大家分享了C++实现两个有序数组合并的具体代码,供大家参考,具体内容如下剑指offer面试题5延展题:问题:有两个排序数组A1和A2,内存在A1的末尾有足够多的空间容纳A2。请实现一个函数,把A2中所有数字...
  • 题目描述: 例如有两个排好序的数组: [1,2,3,4,6,9,11] [2,4,6,8,12,19,33,45] 结果: [1,2,2,3,4,4,6,6,8,9,11,12,19,33,45] ...利用两个数组已经排好序这个条件,设置两个指针,分别指向两个数组 当其中...
  • 方法一:直接比较每一个数据,时间复杂度O(n)  /** ... * merge两个数组 * @param a 递增 * @param b 递增 * @return */ public static int[] merge(int[] a,int[] b){ int i=0,j=0,n=...
  • 合并两个有序数组(C语言)

    千次阅读 2021-11-21 10:52:05
    合并两个有序数组 【题目】 如果不考虑时间复杂度,那么最直接最暴力的方法是先将 nums2 数组拷到 nums1 数组的后面,然后再用一个简单的排序算法,就能解决问题了。但是在时间复杂度上几乎没有优势。 其实,当我们...
  • 题目:有两个有序数组a,b,现需要将其合并成一个新的有序数组。 简单的思路就是先放到一个新的数组中,再排序。但是这样的没体现任何算法,这里考的不是快速排序排序算法。关键应该是如何利用 有序 已知这个条件。...
  • 在说这题目之前先来说说一排序算法 “归并算法” 归并算法采取思想是分治思想,分治思想简单...所以可以由完全二叉树的深度可以得知,整个归并排序需要进行log2n次。然后每一次需要消耗O{n}时间。所以总的时间复杂
  • 合并两个有序数组

    千次阅读 多人点赞 2020-11-22 00:03:16
    今天的题目是 合并两个有序数组,我们先来看下题目要求: 给你两个有序整数数组 nums1 和 nums2,请你将 nums2 合并到 nums1 中,使 nums1 成为一个有序数组。 说明: 初始化 nums1 和 nums2 的元素数量分别为 m ...
  •   这里归并排序只用到了一额外大小为 min(m, n) 的空间,较为巧妙。   如此一来,设置三指针,只需要把当前合适的数放到额外空间中。   由于比较,总会有一个数组先结束,对于后结束的一个数组,如果其...
  • 再去执行merge(arr, lo, mid, hi),然后进行两个元素的比较,排序。 我感觉我这样的理解显然是错误的,我一直弄不懂一个递归函数的下面的执行语句究竟是怎么执行的。比如我假设有一个全局变量i放到了第一个...
  • 寻找两个有序数组的中位数(附上三种解法)

    千次阅读 多人点赞 2019-12-06 18:23:32
    这道题比较经典,我当时在做的时候,想出了种解决方案,不过总感觉算法不够优美,所以找到了另一种我觉得非常精妙的解法,利用了K最小数的思想去解决这道题,很值得讲一下,不知道K最小数的,可以参考我另一篇文章...
  • Python实现归并排序

    千次阅读 2020-07-14 23:10:27
    Python实现归并排序

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 50,787
精华内容 20,314
关键字:

两个有序数组归并排序