精华内容
下载资源
问答
  • 1.建立两个顺序表(通过随机函数生成); 2.排序(升序),输出合并前的结果; 3.对这两个顺序表进行合并(保持升序); 4.输出合并结果
  • 将两个有序顺序表合并为一个新的有序顺序表

    万次阅读 多人点赞 2019-06-28 21:31:16
    将两个有序顺序表合并为一个新的有序顺序表题目要求基本思想核心代码完整代码(C++) 题目要求 将两个有序顺序表合并为一个新的有序顺序表,并由函数返回合并后的顺序表。 基本思想 非常经典的题目,哪怕死记硬背也...

    将两个有序顺序表合并为一个新的有序顺序表

    题目要求

    将两个有序顺序表合并为一个新的有序顺序表,并由函数返回合并后的顺序表。

    基本思想

    非常经典的题目,哪怕死记硬背也应该记下来
    按照顺序不断将两个顺序表表头较小的那个存入新表中,操作结束后,看哪个表还有剩余,将剩下的部分加到新表后面。

    核心代码

    线性表采用动态分配空间的方法,最大容量为MaxSize。

    bool Merge(SeqList A, SeqList B, SeqList &C)
    {//C为合并后的顺序表
    	if (A.length + B.length > C.MaxSize) return false;//超出最大存储空间
    	int i = 0, j = 0, k = 0;
    	while( i < A.length && j < B.length)
    	{
    		if (A.data[i] <= B.data[j])
    			C.data[k++] = A.data[i++];
    		else
    			C.data[k++] = B.data[j++];
    	}
    	while (i < A.length) C.data[k++] = A.data[i++];
    	while (j < B.length) C.data[k++] = B.data[j++];
    	C.length = k;
    	return true;
    }
    

    完整代码(C++)

    //函数功能:
    //将两个有序顺序表合并为一个新的有序顺序表,并由函数返回结果
    
    #include<iostream>
    using namespace std;
    
    #define InitSize 50
    typedef int ElemType;
    typedef struct{
    	ElemType *data;
    	int length, MaxSize;
    }SeqList;
    
    void InitList(SeqList &L)
    {
    	L.data = new ElemType[InitSize];
    	if (!L.data){ cout << "存储空间申请失败!"; return; }
    	L.length = 0;
    	L.MaxSize = InitSize;
    }
    
    bool Merge(SeqList A, SeqList B, SeqList &C)
    {
    	if (A.length + B.length > C.MaxSize) return false;//超出最大存储空间
    	int i = 0, j = 0, k = 0;
    	while( i < A.length && j < B.length)
    	{
    		if (A.data[i] <= B.data[j])
    			C.data[k++] = A.data[i++];
    		else
    			C.data[k++] = B.data[j++];
    	}
    	while (i < A.length) C.data[k++] = A.data[i++];
    	while (j < B.length) C.data[k++] = B.data[j++];
    	C.length = k;
    	return true;
    }
    
    void printList(SeqList L)
    {
    	for (int i = 0; i < L.length; i++)
    		cout << L.data[i] << "  ";
    	cout << endl;
    }
    
    void main()
    {
    	//定义并生成两个顺序表
    	SeqList A; InitList(A);
    	SeqList B; InitList(B);
    	A.length = 4; B.length = 5;
    	for (int i = 0; i < A.length; i++)
    		A.data[i] = 2 * i + 1;
    	for (int i = 0; i < B.length; i++)
    		B.data[i] = 2 * (i + 1);
    	 
    	SeqList C; InitList(C);
    	printList(A);
    	printList(B);
    	 if (Merge(A,B,C)) printList(C);
    }
    
    展开全文
  • 将两个顺序表合并为一个新的顺序表

    千次阅读 多人点赞 2020-09-04 00:23:58
    问题描述:将两个有序顺序表合并为一个新的有序顺序表,并有函数返回结果顺序表。要求时间复杂度O(n) 算法设计思想:首先,按顺序取两个顺序表表头较小的结点存入新的线性表中直到某一个表遍历完;然后将还有剩余...

    问题描述:将两个有序顺序表合并为一个新的有序顺序表,并有函数返回结果顺序表。要求时间复杂度O(n)

    算法设计思想:首先,按顺序取两个顺序表表头较小的结点存入新的线性表中直到某一个表遍历完;然后将还有剩余元素的表的剩下结点加到新的顺序表后。

    代码及结果:

    #include<stdio.h>
    #include "线性表的顺序表示和实现.cpp"
    
    bool Merge(SqList &A,SqList &B,SqList &L){
    	//将有序顺序表A和B合并成一个新的有序顺序表L
    	if(A.length + B.length > MaxSize) //两个表的结点总个数大于顺序表的最大长度
    		return false;
    	int i = 0,j = 0,k = 0;
    	while(i < A.length && j < B.length){ //循环,将表头较小的结点存入线性表中 
    		if(A.data[i] < B.data[j])
    			ListInsert_Sq(L,++k,A.data[i++]);
    		else
    			ListInsert_Sq(L,++k,B.data[j++]);
    	} 
    	while(i < A.length) //将还有剩余元素的表中的剩下结点加到L后 
    		ListInsert_Sq(L,++k,A.data[i++]);
    	while(j < B.length)
    		ListInsert_Sq(L,++k,B.data[j++]); 
    	L.length = k;
    	
    	return true;
    }
    
    int main(){
    	//Test
    	SqList A,B,L;
    	int e;
    	InitList_Sq(A);
    	InitList_Sq(B);
    	InitList_Sq(L);
    	
    	printf("依次输入要往线性表A中输入的元素:"); 
    	int i = 0;
    	while(scanf("%d",&e)!=EOF){
    		ListInsert_Sq(A,++i,e);
    	}		
    	printf("顺序表A中现有的数据为:");
    	PrintList(A);
    	
    	printf("依次输入要往线性表B中输入的元素:"); 
    	i = 0;
    	while(scanf("%d",&e)!=EOF){
    		ListInsert_Sq(B,++i,e);
    	}		
    	printf("顺序表B中现有的数据为:");
    	PrintList(B);
    	
    	printf("合并之后的顺序表为:");
    	Merge(A,B,L);
    	PrintList(L);
    	
    	return 0;
    	
    }

    展开全文
  • 两个有序顺序表合并成一个顺序表,还是有序的
  • 将两个有序顺序表合并为一个新的有序表,并由函数返回结果顺序表。实际过程中应该不断取下两个顺序表表头较小的结点存在新的顺序表中,然后,将其中某个表中的剩余数据直接加到新的顺序表后面。 二 代码实现 /*...

    一 概述

    将两个有序顺序表合并为一个新的有序表,并由函数返回结果顺序表。实际过程中应该不断取下两个顺序表表头较小的结点存在新的顺序表中,然后,将其中某个表中的剩余数据直接加到新的顺序表后面。

    二 代码实现

    /*合并两个有序顺序表*/ 
    #include <iostream>
    using namespace std;
    typedef int ElemType; 
    #define MAXSIZE 100
    #define ERROR 0
    #define OK 1
    
    typedef struct {
    	
    	ElemType *elem;
    	int length;
    }SqList;
    
    int InitOrderList(SqList &L1,SqList &L2,SqList &L3){
    	
    	L1.elem = new ElemType[MAXSIZE];
    	L2.elem = new ElemType[MAXSIZE];
    	L3.elem = new ElemType[MAXSIZE]; 
    	
    	if(!L1.elem || !L2.elem || !L3.elem){
    		
    		return ERROR;
    	}
    	return OK;
    }
    
    int MargeOrderList(SqList L1,SqList L2,SqList &L3){
    	
    	if(L1.length + L2.length > L3.length){
    		return false;
    	}
    
    	int i=0,j=0,k=0;
    	
    	while (i < L1.length && j < L2.length){
    		if(L1.elem[i] <= L2.elem[j]) {
    			L3.elem[k++] = L1.elem[i++];
    		}else {
    			L3.elem[k++] = L2.elem[j++];
    		}
    	}
    	
    	while (i < L1.length) {
    		L3.elem[k++] = L1.elem[i++];
    	}
    	
    	while (j < L2.length) {
    		L3.elem[k++] = L2.elem[j++];
    	}
    	L3.length = k;
    	return OK;
    }
    
    int main(){
    	
    	SqList L1,L2,L3;
    	int select = -1,i; 
    	
    	cout<<"将两个有序表合并成一个有序表!"<<endl;
    	cout<<"1.初始化有序线性表!"<<endl;
    	cout<<"2.插入6个数到有序表L1!"<<endl;
    	cout<<"3.插入7个数到有序表L2!"<<endl;
    	cout<<"4.将有序表L1和L2合并到L3!"<<endl;
    	cout<<"0.退出!"<<endl;
    	
    	while(select != 0){
    		
    		cout<<"请选择:";
    		cin>>select; 
    		switch(select){
    			case 1:
    				if(InitOrderList(L1,L2,L3)){
    					cout<<"有序表初始化成功!"<<endl ; 
    				}else{
    					cout<<"有序表初始化失败!"<<endl;
    				} 
    				break;
    			case 2:
    				for(i = 0; i < 6; i++) {
    					cin>>L1.elem[i];
    				}
    				L1.length = 6;
    				break;
    			case 3:
    				for(i = 0; i < 7; i++) {
    					cin>>L2.elem[i];
    				}
    				L2.length = 7;
    				break;
    			case 4:
    				MargeOrderList(L1,L2,L3);
    				for(i = 0; i < L3.length; i++){
    					cout<<L3.elem[i]<<" ";
    				}
    				cout<<endl;
    				break;
    		}
    	}
    	return 0;
    }

    三 结果

    展开全文
  • 数据结构-两个顺序表合并

    千次阅读 2019-10-10 18:54:32
    #include <stdio.h> #define MaxSize 100 typedef struct { int data[MaxSize];... * 初始化顺序表 * @param L 顺序表L */ void Init_SeqList(SeqList& L) { L.length = 0; } /**...

    数据结构-两个顺序表合并

    #include <stdio.h>
    #define MaxSize 100
    typedef struct {
    	int data[MaxSize];
    	int length;		
    }SeqList;
    
    /**
     * 初始化顺序表
     * @param L 顺序表L
     */
    void Init_SeqList(SeqList& L) {
    	L.length = 0;
    }
    
    /**
     * 创建顺序表,输入数据存入线性表的数组空间中
     * @param L 代表顺序表,使用引用类型
     * @param n 需要插入的元素个数
     */
    int Create_SeqList(SeqList& L, int n) {
    	if (n > MaxSize)
    	{
    		return 0;
    	}
    	for (int i = 0; i < n; ++i)
    		scanf_s("%d", &L.data[i]);
    	L.length = n;
    	return 1;
    }
    
    /**
     * 输出顺序表
     * @param L 顺序表
     */
    void Print_SeqList(SeqList L) {
    	for (int i = 0; i < L.length; i++)
    		printf("%d ", L.data[i]);
    	printf("\n");
    }
    
    
    /**
     * 在第location个位置插入元素elem
     * @param L        顺序表
     * @param location 插入的位置
     * @param elem     插入的元素
     */	
    int Insert_SeqList(SeqList &L, int location, int elem) {
    	if (location<1 || location>L.length+1 || L.length>=MaxSize)
    	{
    		return 0;
    	}
    	for (int i = L.length; i >= location; --i)
    	{
    		L.data[i] = L.data[i-1];
    	}
    	L.data[location - 1] = elem;
    	L.length++;
    	return 1;
    }
    
    /**
     * 合并两个顺序表,组成新的顺序表
     * @param La       待合并顺序表
     * @param Lb       待合并顺序表
     * @param Lc       合并后的顺序表
     */
    void MergeList(SeqList La, SeqList Lb, SeqList &Lc) {
    	Init_SeqList(Lc);
    	int i,j,k;
    	i = j = 0;
    	k = 1;
    	while((i<La.length) && (j<Lb.length)) {
    		if (La.data[i] < Lb.data[j])
    		{
    			Insert_SeqList(Lc, k++, La.data[i++]);
    		}
    		else {
    			Insert_SeqList(Lc, k++, Lb.data[j++]);
    		}
    	}
    	while(i<La.length) {
    		Insert_SeqList(Lc, k++, La.data[i++]);
    	}
    	while(j<Lb.length) {
    		Insert_SeqList(Lc, k++, Lb.data[j++]);
    	}
    }
    
    int main()
    {
       SeqList La, Lb, Lc;
    
       int an,bn;
       scanf_s("%d", &an);
       Create_SeqList(La, an);
       Print_SeqList(La);
       scanf_s("%d", &bn);
       Create_SeqList(Lb, bn);
       Print_SeqList(Lb);
    
       MergeList(La, Lb, Lc);
       Print_SeqList(Lc);
      
       return 0;
    }
    
    

    在这里插入图片描述

    创作不易,喜欢的话加个关注点个赞,谢谢谢谢谢谢!

    展开全文
  • 数据结构-将两个有序顺序表合并为一个新的有序顺序表,并由函数返回结果顺序表 【小白自学写的,有错误请指正!】 c++代码 #include <stdio.h> #include <stdlib.h> #define InitSize 10 #define ...
  • 顺序表合并算法

    千次阅读 多人点赞 2019-08-19 00:48:53
    问题描述:有两个顺序表LA和LB,其元素均为递增有序排列,编写算法,将两个有序列表合并成一个有序的顺序表LC。 思路:先将两个表作比较,输出数字较小的一方,当有一个表已经全部输出后,将另外一个表的剩下的值...
  • 顺序表之两个有序顺序表合并

    千次阅读 2020-06-16 23:09:44
    (2.2.4-7)将两个有序顺序表合并为一个新的有序顺序表。 思路:有序顺序表L1,L2各用j、k两个指针从第一个元素进行遍历比较,一旦k指向的元素大于或者等于j指向的元素就将k指向的元素插在j元素之后。在此首先得默认L1...
  • 顺序表合并

    2012-06-25 13:53:46
    创建两个顺序表,并按非递减有序排列,合并两个顺序表为一个新的非递减有序顺序表
  • 题目:将两个有序顺序表合并为一个新的有序顺序表,并由函数返回结果顺序表 算法思想: 首先,按顺序不断取下两个顺序表表头较小的结点,存入新的顺序表中, 然后,看哪个顺序表还有剩余,将剩下的部分加到新的顺序...
  • C语言数据结构实现顺序表的动态申请内存并且合并,代码可以直接使用。
  • 将两个有序顺序表合并为一个新的有序顺序表,输出合并后的顺序表的所有数据元素; #include<stdio.h> #include<stdlib.h> #define LIST_INIT_SIZE 100 #define LISTINCREMENT 20 typedef struct { int...
  • java将两个顺序表合并为一个顺序表

    千次阅读 多人点赞 2018-10-07 16:54:49
    Main类 package combine; public class Main { public static void main(String[] args) { SeqList a = new SeqList(new int[] { 2,6,9 ,11}); SeqList b = new SeqList(new int[] { 1,7,10});...
  • 题目:将两个有序顺序表合并为一个新的顺序表,并由函数返回结果顺序表 (非常典型的算法方法) 算法思想: 第一步:按顺序不断取下两个顺序表中表头较小的结点,存到新的顺序表中 第二步:看哪个顺序表有剩余,将...
  • eg:顺序表A:1 3 5 7 顺序表B:2 4 6 8 合并后的表C:8 7 6 5 4 3 2 1 **思路:**从后往前遍历顺序表A和B,如果当前A表的数大于等于B表的数,则将A表的数存入C,A的元素下标往前移一位,否则,将B表的数存入C表,B...
  • //将两个有序顺序表合并为一个新的有序表,并由函数返回结果顺序表 typedef struct{ int data[MaxSize]; int Length; }SqList; //1.保证顺序表A+顺序表B的长度不超过MaxSize //2.两个指针分别指向A,B,判断指针...
  • 两个有序顺序表合并为有序顺序表 C++实现 顺序表 C++ C 数据结构 顺序表的排序
  • 将两个有序顺序表合并成一个新的有序顺序表,并由函数返回结果顺序表 算法思想: 没什么可说的,归并 核心代码: int InitSqList(SqList &L) { //按照严版数据结构,不是采用data[MaxSize]而是采用*elem就在...
  • 存在两个有序的顺序表,将两个有序的顺序表合并成一个大的有序的顺序表 解题思路 假设有两个有序的顺序表s1和s2并申请一块s3用于存放最终顺序 依次比较s1和s2,将值小的数存入s3,并将其下标向后挪一个元素直到其中...
  • 数据结构之两个有序顺序表合并

    千次阅读 2020-01-18 15:24:32
    将有序顺序表L1和有序顺序表L2合并为一个新的有序顺序表L: #include<stdio.h> #define MAXSIZE 50 typedef int ElemType; typedef struct{ ElemType data[MAXSIZE]; int len; }SqList; int Merge_List...
  • 两个不同长度的线性表的合并,在合并过程中,两个线性表中共有的元素会自动删掉,合并后的线性表没有排序,如需排序,请看我之前发的线性表之顺序表实验
  • 将俩有序顺序表合并为一个新的有序顺序表,并返回结果 输入: 3 3 1 2 3 4 5 6 输出 1 2 3 4 5 6 输入: 3 3 3 3 4 4 5 5 输出: 3 4 5 思路: 简单比较两个数组大小, 由于有序, 1.如果结果数组当前存储和a...
  • 数据结构——顺序表合并(C语言实现)

    千次阅读 多人点赞 2018-09-13 13:48:36
    好久没来写博客了,最近开学...这里是将有序(从小到大)顺序表A,B 合并为一个有序(由小到大)顺序表C #define MAXSIZE 100 #include&amp;lt;stdio.h&amp;gt; // 定义数据结构,size为顺序表实际元素个...
  • 编写一个算法实现两个有序(非递减有序)顺序表合并成为一个顺序表,假设第一个顺序表存储在A[]中,第二个顺序表存储在B[]中,A[]和B[]的长度为maxSize,maxSize足够大,合并后的结果放在A[]中,不另设新的顺序表...
  • 合并两个有序顺序表

    2015-04-01 18:54:35
    合并两个有序的顺序表,使用语言是C++,数据结构里的一个基础的算法。
  • 编写一个算法,将m(m≥2)个有序(从小到大)顺序表合并成个有序顺序表,假设所有顺序表存储在一个m行maxSie(maxSize足够大)列的二维数组lists[m][maxSize]中,要求把1~m-1行所在的顺序表合并在0行所在的顺序表中,各表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 232,257
精华内容 92,902
关键字:

顺序表的合并