精华内容
下载资源
问答
  • 有序线性表合并

    2015-04-05 18:30:31
    有序线性表合并,用C语言来描述的,是线性表的基本操作
  • 线性表合并

    2014-10-08 20:34:23
    线性表合并,用于数据结构实验,可以下载参考,适合新手
  • 有序顺序线性表合并

    2021-08-26 12:04:43
    已知顺序线性表La和Lb的元素按值非递减排列(例如:La=1,2,3,4,5; Lb=2,4,6,8,10) 归并La和Lb得到新的顺序线性表Lc,Lc的元素也按值非递减排列(要求利用线性表的顺序表示方法及相关操作实现) Input 输入为两行,第...

    Description
    已知顺序线性表La和Lb的元素按值非递减排列(例如:La=1,2,3,4,5; Lb=2,4,6,8,10)
    归并La和Lb得到新的顺序线性表Lc,Lc的元素也按值非递减排列(要求利用线性表的顺序表示方法及相关操作实现)
     
    Input
    输入为两行,第一行为La,第二行为 Lb。

    Output
    输出为三行,第一行为La,第二行为 Lb, 第三行为Lc。

    Sample Input
    1 2 3 4 5
    2 4 6 8 10

    Sample Output
    La= 1 2 3 4 5
    Lb= 2 4 6 8 10
    Lc= 1 2 2 3 4 4 5 6 8 10

    //有序顺序线性表合并 
    #include <bits/stdc++.h>
    #define TRUE		1
    #define FALSE		0
    #define OK			1
    #define ERROR		0
    #define INFEASIBLE	-1
    //#define OVERFLOW	0
    #define LIST_INIT_SIZE	10
    #define LISTINCREMENT	2
    typedef int	Status;
    typedef int	Boolean;
    typedef int ElemType;
    using namespace std;
    
    struct SqList
    {
    	ElemType	*elem;
    	int		length;
    	int		listsize;
    };
    
    Status InitList( SqList &L )
    {
    	L.elem = (ElemType *) malloc( LIST_INIT_SIZE * sizeof(ElemType) );
    	//if ( !L.elem )
    		//exit( OVERFLOW );
    	L.length	= 0;
    	L.listsize	= LIST_INIT_SIZE;
    	return(OK);
    }
    
    
    Status DestroyList( SqList &L )
    {
    	free( L.elem );
    	L.elem		= NULL;
    	L.length	= 0;
    	L.listsize	= 0;
    	return(OK);
    }
    
    Status ClearList( SqList &L )
    {
    	if ( L.elem != NULL )
    	{
    		free( L.elem );
    		L.elem		= NULL;
    		L.length	= 0;
    		L.listsize	= 0;
    		return(OK);
    	}
    }
    
    
    Status ListEmpty( SqList L )
    {
    	if ( L.length == 0 )
    		return(TRUE);
    	else
    		return(FALSE);
    }
    
    
    int ListLength( SqList L )
    {
    	return(L.length);
    }
    
    
    Status GetElem( SqList L, int i, ElemType &e )
    {
    	if ( i < 1 || i > L.length )
    		exit( ERROR );
    	e = *(L.elem + i - 1);
    	return(OK);
    }
    
    
    int LocateElem( SqList L, ElemType e, Status (*compare)( ElemType, ElemType ) )
    {
    	int	i	= 1;
    	int	*p	= L.elem;
    	while ( i <= L.length && !(*compare)(*p++, e) )
    		++i;
    	if ( i <= L.length )
    		return(i);
    	else
    		return(0);
    }
    
    
    Status PriorElem( SqList L, ElemType cur_e, ElemType &pre_e )
    {
    	int		i	= 2;
    	ElemType	*p	= L.elem + 1;
    	while ( i <= L.length && *p != cur_e )
    	{
    		p++;
    		i++;
    	}
    	if ( i > L.length )
    		return(INFEASIBLE);
    	else{
    		pre_e = *--p;
    		return(OK);
    	}
    }
    
    
    Status ListInsert( SqList &L, int i, ElemType e )
    {
    	if ( i < 1 || i > L.length + 1 )
    		return(ERROR);
    	if ( L.length >= L.listsize )
    	{
    		cout << "L.length>=L.listsize" << endl;
    		ElemType *newbase = (ElemType *) realloc( L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType) );
    		cout << "ElemType *newbase" << endl;
    		//if ( !newbase )
    			//exit( OVERFLOW );
    		L.elem		= newbase;
    		L.listsize	+= LISTINCREMENT;
    	}
    	ElemType	*q = &(L.elem[i - 1]);
    	ElemType	*p;
    	for ( p = &(L.elem[L.length - 1]); p >= q; --p )
    		*(p + 1) = *p;
    	*q = e;
    	++L.length;
    	return(OK);
    }
    
    Status unionsql(SqList &L1,SqList &L2,SqList &L3)
    {
    	int l=1;
    	int *p=L1.elem;
    	int a[L1.length+L2.length+1];
    	for(int i=1;i<=L1.length;++i)
    		a[l++]=*p++;
    	int *q=L2.elem;
    	for(int i=1;i<=L2.length;++i)
    		a[l++]=*q++;
    	sort(a+1,a+L1.length+L2.length+1);
    	for(int i=1;i<=L1.length+L2.length;++i)
    		ListInsert(L3,i,a[i]);
    	return OK;
    }
    
    
    Status ListDelete( SqList &L, int i, ElemType &e )
    {
    	if ( (i < 1) || (i > L.length) )
    		return(ERROR);
    	ElemType *p, *q;
    	p	= &(L.elem[i - 1]);
    	e	= *p;
    	q	= L.elem + L.length - 1;
    	for ( ++p; p <= q; ++p )
    		*(p - 1) = *p;
    	--L.length;
    	return(OK);
    }
    
    void showsql(SqList &l)
    {
    	int *p=l.elem;
    	cout<<*p++;
    	for(int i=2;i<=l.length;++i)
    		cout<<" "<<*p++;
    }
    
    
    int main()
    {
    	int temp[1000],temp2;
    	char temp1[1000];
    	SqList		La,Lb,Lc;
    
    	InitList( La );
    	InitList( Lb );
    	InitList( Lc );
    /*
    	int l=1;
    	gets(temp1);
    	for(int i=0;i<strlen(temp1)+1;++i)
    	{
    		if(temp1[i]==' ')
    		{
    			temp[l++]=temp2;
    			temp2=0;
    		}
    		else
    			if(temp1[i]!='\0')
    			{
    				temp2=temp2*10+(temp1[i]-'0');
    			}
    			else
    				temp[l]=temp2;
    	}
    
    	for(int i=1;i<=l;++i)
    	{
    		ListInsert(La,i,temp[i]);
    	}
    
    	gets(temp1);
    	l=1;
    	temp2=0;
    	memset(temp,0,sizeof(temp));
    	memset(temp,0,sizeof(temp1));
    
    	for(int i=0;i<strlen(temp1)+1;++i)
    	{
    		if(temp1[i]==' ')
    		{
    			temp[l++]=temp2;
    			temp2=0;
    		}
    		else
    			if(temp1[i]!='\0')
    			{
    				temp2=temp2*10+(temp1[i]-'0');
    			}
    			else
    				temp[l]=temp2;
    	}
    
    	for(int i=1;i<=l;++i)
    	{
    		ListInsert(Lb,i,temp[i]);
    	}
    */
    	for(int i=1;i<=5;++i)
    	{
    		cin>>temp2;
    		ListInsert(La,i,temp2);
    	}
    	for(int i=1;i<=5;++i)
    	{
    		cin>>temp2;
    		ListInsert(Lb,i,temp2);
    	}
    	cout<<"La= ";
    	showsql(La);
    	cout<<endl;
    	cout<<"Lb= ";
    	showsql(Lb);
    	cout<<endl;
    	unionsql(La,Lb,Lc);
    	cout<<"Lc= ";
    	showsql(Lc);
    	cout<<endl;
    
    }
    

    展开全文
  • 线性表合并算法

    2021-01-12 00:00:48
    线性表顺序存储实验3 已知两个非递减序列LA和LB,LA: 1,3,9,9,12,13,18,21 LB: 2,4,6,10,15,19,22,23,25 使用线性表合并算法,合并LA和LB为LC,要求仍然为非递减序列,并输出LC. COMMON.H #include<stdio.h> #...

    线性表顺序存储实验3 已知两个非递减序列LA和LB,LA: 1,3,9,9,12,13,18,21 LB: 2,4,6,10,15,19,22,23,25 使用线性表合并算法,合并LA和LB为LC,要求仍然为非递减序列,并输出LC.

    COMMON.H
    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include<time.h> //用于设置随机数种子用

    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0

    SEQLIST.H
    #include"common.h"
    /*
    *头文件中最好只包含全局变量的声明,函数声明,宏定义等代码,
    *不建议包括函数的完整实习代码,以免报重复引用错误。
    *函数代码实现部分在seqlist.c中完成
    */
    #define ElemType int
    #define MAXSIZE 100 /此处的宏定义常量表示线性表可能达到的最大长度/

    typedef struct
    {
    ElemType elem[MAXSIZE]; /线性表占用的数组空间/
    int last; /记录线性表中最后一个元素在数组elem[ ]中的位置(下标值),空表置为-1/
    } SeqList;

    //函数功能:顺序表中查找值为e的元素位置
    //输入参数L:顺序表
    //输入参数e:要查找的元素
    //返回值:若找到则返回顺序表中的位置(下标+1),否则返回-1
    int Locate(SeqList L,ElemType e);

    //函数功能:在顺序表指定位置插入值e
    int InsList(SeqList *L, int i,ElemType e);

    /在顺序表L中删除第i个数据元素,并用指针参数e返回其值/
    //函数功能:删除顺序表中的指定位置i上的元素
    int DelList(SeqList *L,int i,ElemType *e) ;

    //函数功能:输出顺序表的值
    void SeqPrint(SeqList *L);

    //函数功能:LA与LB表合并算法
    void Merge(SeqList *LA, SeqList *LB, SeqList *LC);

    SEQLIST.C
    #include"seqlist.h"

    //函数功能:顺序表中查找值为e的元素位置
    //输入参数L:顺序表
    //输入参数e:要查找的元素
    //返回值:若找到则返回顺序表中的位置(下标+1),否则返回-1
    int Locate(SeqList L,ElemType e)
    {
    int i=0; /i为扫描计数器,初值为0,即从第一个元素开始比较/
    while((i<=L.last)&&(L.elem[i]!=e)) /顺序扫描表,直到找到值为e的元素, 或扫描到表尾而没找到/
    i++;
    if(i<=L.last)
    return(i+1); /若找到值为e的元素,则返回其序号/
    else
    return(-1); /若没找到,则返回空序号/
    }

    //函数功能:在顺序表指定位置插入值e
    int InsList(SeqList *L, int i,ElemType e)
    {
    int k;
    if(i<1||(i>L->last+2)) //首先判断插入位置是否合法
    {
    printf(“插入位置i不合法”);
    return(ERROR);
    }
    if(L->last>=MAXSIZE-1)
    {
    printf(“表已满,无法插入”);
    return(ERROR);
    }

    for(k=L->last;k>=i-1;k--)			//插入元素位置之后的元素逐个向后移动 
    {
    	L->elem[k+1]=L->elem[k]; 
    } 
    L->elem[i-1]=e;						//在C语言中数组第i个元素的下标为i-1
    L->last++; 							//尾指示器增加1 
    return(OK);
    

    }
    /在顺序表L中删除第i个数据元素,并用指针参数e返回其值/
    //函数功能:删除顺序表中的指定位置i上的元素
    int DelList(SeqList *L,int i,ElemType *e)
    {
    int k;
    if((i<1)||(i>L->last+1))
    {
    printf(“删除位置不合法!”);
    return(ERROR);
    }
    *e= L->elem[i-1]; //将删除的元素存放到e所指向的变量中
    for(k=i;k<=L->last;k++) //此句教材代码有误
    L->elem[k-1]= L->elem[k]; //将后面的元素依次前移
    L->last–; //尾指示器-1
    return(OK);
    }

    //函数功能:输出顺序表的值
    void SeqPrint(SeqList *L)
    {
    printf(“当前线性表中数据为:\n”);
    int i;
    for(i=0;i<=L->last;i++)
    printf("%d “,L->elem[i]);
    printf(”\n");
    }
    //函数功能:LA与LB表合并算法
    void Merge(SeqList *LA, SeqList *LB, SeqList *LC)
    {
    int i, j, k;
    i=0; j=0; k=0;
    while(i<=LA->last && j<=LB->last) //遍历两个线性表
    { if(LA->elem[i]<=LB->elem[j]) //如果 LA(i)的当前元素值小,则LA(i)放入LC中
    {
    LC->elem[k]= LA->elem[i];
    i++; }
    else //否则LB(j)放入LC中
    {
    LC->elem[k]=LB->elem[j];
    j++;
    }
    k++;
    }
    while(i <= LA->last) //将表LA余下的元素赋给表LC
    {
    LC->elem[k] = LA->elem[i];
    i++; k++;
    }
    while(j <= LB->last) //将表LB余下的元素赋给表LC
    {
    LC->elem[k]= LB->elem[j];
    j++; k++;
    }
    LC->last=LA->last+LB->last+1; //LC的尾指示器赋值
    }

    MAIN.C
    #include"seqlist.h"
    /*
    已知两个非递减序列LA和LB,
    LA: 1,3,9,9,12,13,18,21
    LB: 2,4,6,10,15,19,22,23,25
    使用线性表合并算法,合并LA和LB为LC,要求仍然为非递减序列,并输出LC.
    */
    int main()
    {
    //创建顺序表并录入值
    SeqList LA,LB,LC;
    int i,len;
    int loc,v,m;
    //LA,LB赋值
    LA.last=7;
    LB.last=8;
    LA.elem[0]=1; LA.elem[1]=3; LA.elem[2]=9; LA.elem[3]=9;
    LA.elem[4]=12; LA.elem[5]=13; LA.elem[6]=18; LA.elem[7]=21;
    SeqPrint(&LA); //输出当前线性表内容
    LB.elem[0]=2; LB.elem[1]=4; LB.elem[2]=6; LB.elem[3]=10;
    LB.elem[4]=15; LB.elem[5]=19; LB.elem[6]=22; LB.elem[7]=23;
    LB.elem[8]=25;
    SeqPrint(&LB); //输出当前线性表内容

    //合并线性表 
    Merge(&LA,&LB,&LC);
    printf("合并后的LC为:\n");
    SeqPrint(&LC); 
    //system("pause");          //防止运行结果窗口自动关闭 
    return 0;
    

    }

    展开全文
  • 这两个线性表合并以后的结果通过La返回,所以在La前面加上& 先求两个链表的长度 在链表b中每个元素依次去看,链表a中有没有 GetElem:每个元素都从Lb中取出来,看看它的值, 然后if(!LocateElem(La...

    有序表这里为什么说非递减而不是递增呢?

     

    因为他们不是严格的递增,La和Lb中可能会有重复的元素,值相等,值相等就不能说递增了,相等的元素可以都出现在里面

     

    依次:要用到循环来实现了

    大概思路:这里没有详细说明用什么表来存储

    这两个线性表合并以后的结果通过La返回,所以在La前面加上&

     

    先求两个链表的长度

    在链表b中每个元素依次去看,链表a中有没有

    GetElem:每个元素都从Lb中取出来,看看它的值,

    然后if(!LocateElem(La,e)):在La中进行比较,如果没找到,返回0,0的非为真,这时就找到的元素插入到线性表a中

    时间复杂度:每个Lb中的元素都要从La中去顺序查找,要执行多少次呢?La的长度次

    相乘

     

    展开全文
  • 两个线性表合并

    千次阅读 2019-09-29 11:51:32
    # include # include ..."请输入线性表元素个数...//线性表LA和LB合并,保存到LC mergeList ( LA , LB , LC ) ; printf ( "合并以后的顺序表LC为:\n" ) ; PrintL ( LC ) ; return 0 ; }
    #include <stdio.h>
    #include <stdlib.h>
    #define MAXSIZE 100
    
    typedef int ElemType;
    
    typedef struct Node
    {
    	ElemType elem [MAXSIZE];
    	int last;
    }*SeqList;
    
    SeqList Init_SeqList()
    {
    	SeqList L;
    	L = (SeqList)malloc(sizeof(Node));
    	L->last = 0;
    	return L;
    }
    
    void Create(SeqList L)
    {
    	int N;
    	printf("请输入线性表元素个数:");
    	scanf("%d", &N);
    	printf("请输入%d个线性表元素(以空格分隔):\n", N);
    	for(int i = 0; i < N; i++)
    	{
    	    scanf("%d", &L->elem[i]);
    	    L->last++;
    	}
    }
    
    void mergeList(SeqList LA,SeqList LB,SeqList LC)
    {
    	int i=0, j=0, k=0;
        
    	while(i < LA->last && j < LB->last)
        {
            //将两者中较小的先放入LC
            if(LA->elem[i] <= LB->elem[j])
            {
                LC->elem[k++] = LA->elem[i++];
            }
            else
            {
                LC->elem[k++]=LB->elem[j++];
            }
        }
        
        //若LA仍然有元素,则直接复制到LC
    	while(i < LA->last)
    	{
    		LC->elem[k++]=LA->elem[i++];
    	}
        //若LB仍然有元素,则直接复制到LC
    	while(j < LB->last)
    	{
    		LC->elem[k++] = LB->elem[j++];
    	}
        //LC的元素个数为二者之和
    	LC->last = LA->last + LB->last;
    }
    
    void PrintL(SeqList L)
    {
    	int i;
    	printf("线性表的元素个数为%d\n", L->last);
        for(i = 0;i < L->last; i++)
    	{
    		printf("%d ", L->elem[i]);
    	}
    	printf("\n");
    }
    
    int main()
    {
    	SeqList LA,LB,LC;
    
        //线性表初始化
    	LA = Init_SeqList();
    	LB = Init_SeqList();
        LC = Init_SeqList();
    
        //线性表创建及输出
    	Create(LA);
    	printf("LA的顺序表序列为:\n");
    	PrintL(LA);
    	Create(LB);
    	printf("LB的顺序表序列为:\n");
    	PrintL(LB);
    
        //线性表LA和LB合并,保存到LC
    	mergeList(LA,LB,LC);
        
    	printf("合并以后的顺序表LC为:\n");
        PrintL(LC);
    
    	return 0;
    }
    
    
    展开全文
  • 数据结构-线性表合并 C语言源码

    千次阅读 多人点赞 2019-03-17 12:57:46
    数据结构-线性表合并 C语言源码 #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; struct HB{ int*elem; int length; }; void ko(HB&amp;amp;amp; l,int n...
  • 线性表合并——合并两个集合

    千次阅读 2020-05-27 15:46:04
    现有两个线性表LA和LA分别表示两个集合A和B,合并为一个新的集合A=A∪B. 完整代码如下: #include <cstdio> #include <cstdlib> #include <algorithm> #include <malloc.h> #include <...
  • 两个线性表合并为一算法实现

    千次阅读 2020-10-09 20:58:26
    LA和LB是两个int型数组,将他们合并为一个数组LC (课本P20算法2.1) #include<stdio.h> #define len_LA 4 #define len_LB 7 //函数-获取元素 int getElem(int *list,int index) { return list[index-1];...
  • 若线性表LA与LB中的数据元素是按非递减有序排列的,现在要把这两个线性表合并为一个新的非递减有序排列的线性表LC,那么应该用到什么算法呢? 其实,我们需要两个指针i、j,分别指向LA、LB中的某个元素,然后比较两...
  • 1、选择顺序或链式存储结构实现线性表的基本操作 2、采用顺序或链式存储方式存储线性表,在此基础上实现线性表的各个操作,以及线性表合并操作
  • #include using namespace std;... cout 合并后的集合" ; while (pa) { cout << pa->data ; pa = pa->next; } } int main() { LinkList HA, HB; Input(HA); cout ; Input(HB); MergeList(HA, HB); return 0; }
  • 这个程序的功能是将两个有序线性表合并为一个有序线性表,要求另辟空间。
  • 线性表合并 数据结构

    2011-05-01 20:26:39
    此源代码利用书中算法 进行自己的扩充 有一定的原创性,并且测试结果还不错。
  • 线性表合并是程序设计语言编译中的一个最基本的问题,现在有两个线性表LA和LB,其中的元素都是按照非递减有序排列的,要将两个LA和LB归并为一个新的线性表LC,使得LC中的元素仍然是非递减有序的。 本实验的合并方式...
  • 线性表合并

    2011-10-23 09:59:43
    线性表用c语言实现合并数据结构(严)版上机实验的实现
  • 顺序线性表合并操作(完整代码)

    千次阅读 2018-08-18 10:08:58
    线性表合并操作:已知la,lb中元素按非递减排列,归并la和lb的元素放入lc中,其也按非递减排列。 代码实现: #include&lt;stdio.h&gt; #include &lt;stdlib.h&gt; //定义杂项函数及内存分配函数...
  • 线性表合并/c语言

    2011-04-15 20:37:35
    该程序功能强大,是用数据结构的单链表实现的,是面向过程的win32控制台程序,输入线性表的数据的时候,不用输入要建立的节点个数,直接以回车结束,数与数间以空格隔开
  • 参考书籍:数据结构(C语言版)--严蔚敏(清华大学出版社) 最近在学数据结构,选用以上参考数据,书中的例子只是一个编程参考,并不能直接使用,这里我...这就要求:扩大线性表LA,将存在于线性表LB中而不存在与线性表
  • 简述顺序存储结构和链式存储结构的优缺点 ① 顺序存储时,相邻数据元素的存放地址也相邻(逻辑与物理统一);要求内存中可用存储单元的地址必须是连续的。 优点:存储密度大(=1),存储空间利用率高。...
  • 数据结构—一般线性表合并

    千次阅读 多人点赞 2019-06-21 10:06:52
    1.一般线性表合并 问题描述:假设利用两个线性表La和Lb分别表示两个集合A和B,现要求一个新的集合 A=A∪B。 La=(7, 5, 3, 11) Lb=(2, 6, 3) La=(7, 5, 3, 11, 2, 6) 算法步骤: 依次取出Lb中的每个元素,...
  • 12.线性表合并详解

    2020-12-05 21:26:56
    线性表合并 问题描述:假设利用两个线性表La和Lb分别表示两个集合A,B,现要求一个新的集合A=A∪B La=(7,5,3,11)Lb=(2,6,3)A=(7,5,3,11,2,6) 算法步骤:(A既是参数又是操作的结果) 依次(需要循环)取出Lb中的每个...
  • 一般线性表合并(C语言描述)

    千次阅读 多人点赞 2020-10-20 13:20:26
    假设利用两个线性表 LA 和 LB 分别表示两个集合 A 和 B (即线性表中的数据元素为集合中的成员),现要求一个新的集合 A = AUB .假如,设 LA = (7,5,3,11) LB = (2,6,3) 合并后 LA = (7,5,3,11,2,6) 二、算法 (1)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,091
精华内容 4,836
关键字:

线性表的合并