怎样用C++实现两个有续线性表合并成一个有续线性表
以前写的，懒得分拆了。直接贴过来。里面有有序表的各种操作。链表的思想是差不多的。
判断
while（pa->next!=null&&pb->next!=null)
{
if(pa->data>pb->data) pb->data插入到新建c链表的的表尾。pb=pb->next;
if(pa->datadata) pa->data 插入c表为。 pa=pa->next;
}
最后没查完的链表剩余部分整体连接到c的表尾。用指针。很简单。
这是有序表的。你想用泛型编程的话，改造一下就行了。
#include
const int MaxLen=100;
typedef struct
{
int data[MaxLen];
int Len;
}seqlist;
void initial_list(seqlist *L)//初始化；
{
L->Len=0;
}
void list_getdata(seqlist *L) //输入线性表
{
std::cout<<"输入线性表长度:";
std::cin>>L->Len;
std::cout<<"输入数据:" ;
for(int i=0;iLen;i++)
std::cin>>L->data[i];
}
int list_Len(seqlist L)//获得线性表的长度；
{
std::cout<<"线性表长度为：" ;
return(L.Len);
}
void get_element(seqlist L,int i) //找到第i个数据 ；
{
int x;
if(iL.Len)
std::cout<<"超出范围，错误"<<std::endl;
else x=L.data[i-1];
std::cout<<"第"<<i<<"个数据为：" ;
std::cout<<x<<std::endl;
}
void get_locate(seqlist L,int x)//找到值等于x的数据位于线性表的第几个元素；
{
for(int i=0;i<L.Len;i++)
{
if(L.data[i]==x)
std::cout<<i+1;
else
std::cout<<"error:无此数据";
}
}
void list_insert(seqlist *L,int i,int x)//将x插入线性表的第i个位置；
{
int j;
if(L->Len==MaxLen)
std::cout<<"溢出"<<std::endl;
else if(iL->Len+1)
std::cout<<"插入位置错误"<<std::endl;
else
{
for(j=L->Len;j>i-1;j--)
L->data[j]=L->data[j-1];
L->data[i-1]=x;
L->Len++;
}
}
void list_delete(seqlist *L,int i)//删除第i个元素；
{
if(L->Len<=0)
std::cout<<"溢出出错"<<std::endl;
else if(i>L->Len||i<1)
std::cout<<"删除位置出错"<<std::endl;
else
for(int j=i-1;jLen-1;j++)
L->data[j]=L->data[j+1];
L->Len--;
}
void list_print(seqlist L)//输出线性表；
{
std::cout<<"线性表为:"<<std::endl;
for(int i=0;i<L.Len;i++)
std::cout<<L.data[i]<<' ';
}
bool list_b_include_a(seqlist *A,seqlist *B)//判断包含关系；
{
int i,j;
bool suc;
for(i=0;iLen;i++)
{
j=0;suc=0;
while(jLen&&suc==0)
if(A->data[i]==B->data[j])
suc=1;
else j++;
if(suc==0) return false;
}
if(suc==1) return true;
}
bool list_b_include_a_YouXu(seqlist *A,seqlist*B)//判断有序数列包含关系
{
int ia=0,ib=0;
while(iaLen&&ibLen)
if(A->data[ia]==B->data[ib])
{
ia++;
ib++;
}
else if(A->data[ia]>B->data[ib]) ib++;
else return false;
if(ia==A->Len) return true;
else return false;
}
void list_combin(seqlist *A,seqlist *B)//合并两个表
{
int m=A->Len;
for(int i=0;iLen;i++)
{
list_insert(A,m+i+1,B->data[i]);
}
list_print(*A);
}
void list_combin_YouXu(seqlist *A,seqlist *B,seqlist *C)//合并有序数列
{
int ia=0,ib=0,ic=0;
while(iaLen&&ibLen)
if(A->data[ia]==B->data[ib])
{
C->data[ic++]=A->data[ia++];
C->data[ic++]=B->data[ib++];
}
else if(A->data[ia]data[ib])
C->data[ic++]=A->data[ia++];
else C->data[ic++]=B->data[ib++];
while(iaLen) C->data[ic++]=A->data[ia++];
while(ibLen) C->data[ic++]=B->data[ib++];
C->Len=ic;
}
int main()
{
/*seqlist L1;
initial_list(&L1);
std::cout<<list_Len(L1)<<std::endl;
list_getdata(&L1);
//std::cout<<std::endl;
std::cout<<list_Len(L1);
std::cout<<std::endl;
get_element(L1,3);
list_print(L1);
list_insert(&L1,4,127);
std::cout<<std::endl;
list_print(L1);
list_delete(&L1,2);
std::cout<<'
';
list_print(L1);
*/
/* int i=1; ;
while(i==1)
{
std::cout<<"**********判断La是否是Lb的子集***********"<<std::endl;
seqlist La,Lb;
list_getdata(&La);//La={1,3,8}
list_print(La);
list_getdata(&Lb);//Lb={2,1,8,6,9,3}
list_print(Lb);
std::cout<<list_b_include_a(&La,&Lb);
std::cout<<"是否继续？"<<"1:是 2：否"<<std::endl;
std::cin>>i;
} */
std::cout<<"合并俩个线性表"<<std::endl;
seqlist L1,L2,L3;
list_getdata(&L1);
list_getdata(&L2);
//list_combin(&L1,&L2);
list_combin_YouXu(&L1,&L2,&L3);
list_print(L3);
return 0;
}
从键盘输入两个链表，通过程序对他们排序，之后按递增顺序合并链表
#include "stdio.h"
#include "stdlib.h"
#include "malloc.h"
#define NULL 0
struct List
{
int data;
struct List *next;
}List;
struct List * InitList()
{
struct List *head,*p,*q;
int d;
head=(struct List *)malloc(sizeof(struct List));
head->next=NULL;
p=head;
scanf("%d",&d);
while(d>0)
{
q=(struct List *)malloc(sizeof(struct List));
q->next=NULL;
q->data=d;
p->next=q;
p=p->next;
scanf("%d",&d);
}
return head;
}
void ListChooseSort(struct List *head)
{
struct List *p,*q;
int t;
if(head->next!=NULL)
{
for(p=head->next;p->next;p=p->next)
for(q=p->next;q;q=q->next)
if(q->datadata)
{
t=p->data;
p->data=q->data;
q->data=t;
}
}
}
struct List * UniteList(struct List *a,struct List *b)
{
struct List *U_head,*p,*q,*s;
U_head=(struct List *)malloc(sizeof(struct List));
U_head->next=NULL;
p=a->next;
q=b->next;
s=U_head;
while(p&&q)
{
if(p->data>q->data)
{
s->next=q;
q=q->next;
}
else
{
s->next=p;
p=p->next;
}
s=s->next;
}
if(p==NULL)s->next=q;
else s->next=p;
return U_head;
}
void ListPrint(struct List *head)
{
struct List *p;
p=head->next;
printf("
");
while(p)
{
printf("%5d",p->data);
p=p->next;
}
printf("
");
}
void main ()
{
struct List *a_head,*b_head,*Unite_head;
printf("
创建链表a：
");
a_head=InitList();
printf("
链表a：");
ListPrint(a_head);
system("pause");
system("cls");
printf("
创建链表b：
");
b_head=InitList();
printf("
链表b：");
ListPrint(b_head);
system("pause");
system("cls");
ListChooseSort(a_head);
printf("
递增排序后的链表a：");
ListPrint(a_head);
ListChooseSort(b_head);
printf("递增排序后的链表b：");
ListPrint(b_head);
Unite_head=UniteList(a_head,b_head);
printf("合并后的链表为：");
ListPrint(Unite_head);
}
2.或者新建一个有续线性表，再将两个表分别插入
3.或者自己写一个线性表，当插入的时候自动插入到有序的位置
其实关键就是你的插入操作:
假设：每个节点为node类型,其数据为整形，单向线性表为list，以整数的升序形成有续表
int insert(node *insertnode)
{
node *temp=list;
while (temp->next != null)
{
if (temp->data <= insertnode->data)//如果要插入的数据比当前的大，则找到其位置，将其插入
{
insertnode->next=temp->next;//将要插入的节点的下一个指向当前节点的下一个元素
temp->next=insertnode;//当前节点的下一个元素指向要插入的节点
break;//退出循环
}
temp=temp->next;//指向下一个元素
}
if (temp->next==NULL)//要插入的元素比所有的都大，将其插入到最后,temp已经指向最后
{
insertnode->next=NULL;
temp->next=insertnode;//当前节点的下一个元素指向要插入的节}
}
第一个表插入第二个表
这样最省事
具体插入函数可以做一些选择，让你的插入效率高一些。
将两个有序线性表合并成一个有序线性表,用C语言 在线急等!!!
答：printf("输入%d个升序元素（空格隔开）：",n1);for(i=0;i<n1;i++)scanf("%d",&a[i]);printf("输入第二个数组元素个数：");scanf("%d",&n2);printf("输入%d个升序元素（空格隔开）：",n2);for(i=0;i<n2;i++)scanf("%d",&b[i]);n3=merge(a,n1,b,n2,s); //a和b数...
急需数据结构算法C语言版:假设有两个元素递增的有序排列线性表A和B...
答：while(flag){ c=getchar();if(c!='$'){ s=(Node *)malloc(sizeof(Node));s->data=c;s->next=L->next;L->next=s;} else flag=0;} } void CreatFromTail(LinkList L){Node *r,*s;int flag=1;char c;r=L;while(flag){ c=getchar();if(c!='$'){s=(Node *)malloc(...
试编写一个算法,将两个有序线性表合成一个有序线性表...最好是在c++...
答：else //将B的data[n]插入C头部 { insert(C,1,B.data[n]);n++;
如何用c语言编合并两个顺序线性表的程序?
答：1、 一开始的思路：把A、B都丢进C里，然后对C排序。人们一开始想到的总是最懒的办法，往往是最没效率的。 改进：由于A、B是排好序的，先把A丢进C里，再拿B元素一个个往里查找插入。这么做要频繁移动元素，如果线性表不是链表的话，开销很大。 再改进：从A、B中各拿一个元素出来，比较后把...
C语言合并两个线性表,输入为表L1=(2,3),L2=(3,4,6)顺序已知,输出为表...
答：define OVERFLOW -1 /*线性表的定义*/ typedef struct sqlist { int *a;int length;int listsize;}sqlist ;sqlist la,lb,lc;/*建立一个空表*/ sqlist initlist(){ sqlist l;l.a = (int*)malloc(listinitsize*sizeof(int));if(!l.a)exit(OVERFLOW);l.length = 0;l.listsize =...
用c++编写程序,求两线性表的交集,并集,差集。
答：//直接上代码：#include<iostream>using namespace std;int main(){int a,b;int c,d;cout<<"请输入第一个闭区间的a,b"<<endl;cin>>a>>b;cout<<"请输入第二个闭区间的c,d"<<endl;cin>>c>>d;if(a>b||c>d) {cout<<"输入的区间不合法"<<endl;}else{if(d<a){cout<<"交集...
用C语言实现两个线性链表的归并
答：typedef struct node{ int data;struct node *next;}LinkList;/* 建立链表 */ LinkList *create_link(int m){ LinkList *head,*s,*p;int i;head=(LinkList *)malloc(sizeof(LinkList));head->next=NULL;p=head;for(i=0;i<m;i++){ s=(LinkList *)malloc(sizeof(LinkList));if(...
求大神帮忙用C语言写一个程序。 要求:定义两个线性表(内容由用户输入...
答：// 向线性表插入元素 bool add_list(List* li, int data){ if(li->top >= li->length){ return false;} li->data[li->top++] = data;return false;} // 将两个线性表合并并对元素进行排序 void merge_list(List *dest, List *li1, List *li2){ list_init(dest, li1->top+...
c语言有序线性表合并数据
答：< numOfLb做以下:5.1 pRes[counterRes]赋值为 Lb[i]5.2 counterRes和i两者增一;6,否则,从i = couterLa 至i < numOfLa做以下:6.1 pRes[counterRes]赋值为 La[i]6.2 counterRes和i两者增一;7结束,pRes中保存合并的线性表数据,数据个数为counterRes;在此基础上,也可以写出链表的算法 ...
如何用c程序建立两个线性表并把他们合并成一个线性表?
答：从键盘输入两个链表，通过程序对他们排序，之后按递增顺序合并链表 include "stdio.h"include "stdlib.h"include "malloc.h"define NULL 0 struct List { int data;struct List *next;}List;struct List * InitList(){ struct List *head,*p,*q;int d;head=(struct List *)malloc(sizeof(...
