数据结构单链表实验.docx
《数据结构单链表实验.docx》由会员分享，可在线阅读，更多相关《数据结构单链表实验.docx（17页珍藏版）》请在冰豆网上搜索。
数据结构单链表实验
#include“iostream.h”
#include"Linkedlist.h"
intmain（intargc,char*argv[]）
{
listl,p,l1,l2,l3;
inti,x;
intnChoice=-1;//操作选择
do
{
//显示主菜单
cout<<"*******************************************************************************\n";
cout<<"*0-退出|1-尾插法创建单链表\n";
cout<<"*2-头插法创建单链表|3-销毁单链表\n";
cout<<"*4-求链表长度|5-求单链表中第i个元素\n";
cout<<"*6-在第i个结点前插入值为x的结点|7-链表中查找元素值为x的结点\n";
cout<<"*8-删除单链表中第i个元素结点|9-递增有序单链表插入元素\n";
cout<<"*10-单链表中奇偶数项分开|11-求两个递增有序单链表L1和L2中的公共元素\n";
cout<<"*12-删除递增有序单链表中的重复元素|13-两个递增有序单链表合并\n";
cout<<"*******************************************************************************\n";
cout<<"请输入数字选择操作：
";
cin>>nChoice;
switch（nChoice）
{
case1:
//尾插法创建单链表
cout<<"请输入单链表中元素（9999退出）：
"<l.create_r（）;
l.print（）;
l.destroy（）;
cout<break;
case2:
//头插发创建单链表
cout<<"请输入单链表中元素（9999退出）：
"<p.create_h（）;
p.print（）;
l.destroy（）;
cout<break;
case3:
//
cout<<"请输入单链表中元素（9999退出）：
"<l.create_r（）;
l.destroy（）;
cout<break;
case4:
//求链表长度
cout<<"请输入单链表中元素（9999退出）：
"<l.create_r（）;
cout<<"链表长度为：
";
cout<l.destroy（）;
break;
case5:
//求单链表中第i个元素
cout<<"请输入单链表中元素（9999退出）：
"<l.create_r（）;
cout<<"请输入要查找元素的序号：
";
cin>>i;
if（l.get_element（i,x）==false）cout<<"要查找的元素不存在！
"<elsecout<<"找到您要查找的元素为：
"<l.destroy（）;
break;
case6:
//在第i个结点前插入值为x的结点
cout<<"请输入单链表中元素（9999退出）：
"<l.create_r（）;
cout<<"请输入要插入的位置及数值"<cout<<"位置序号：
";
cin>>i;
cout<cout<<"数值:
";
cin>>x;
cout<l.insert（i,x）;
l.print（）;
l.destroy（）;
cout<break;
case7:
//链表中查找元素值为x的结点
cout<<"请输入单链表中元素（9999退出）：
"<l.create_r（）;
cout<<"请输入要查找元素的值x：
";
cin>>x;
if（l.locate（x）==false）
cout<<"你查找的元素不存在！
"<elsecout<<"你查找元素的指针为l:
"<l.destroy（）;
case8:
//删除单链表中第i个元素结点
cout<<"请输入单链表中元素（9999退出）：
"<l.create_r（）;
cout<<"请输入你要删除节点的序号i：
";
cin>>i;
if（l.delete_element（i）==false）cout<<"你要删除的节点不存在！
"<else{l.delete_element（i）;
l.print（）;
cout<l.destroy（）;
break;
case9:
//递增有序单链表插入元素
cout<<"请输入单链表中元素（9999退出）：
"<l.create_r（）;
cout<<"请输入你要插入的元素x：
";
cin>>x;
l.insert1（x）;
l.print（）;
cout<l.destroy（）;
break;
case10:
//单链表中奇偶数项分开
cout<<"请输入单链表中元素（9999退出）：
"<l.create_r（）;
cout<<"原表为：
"<l.print（）;
cout<l.division（l,l1,l2）;
cout<<"偶数项为：
";
l1.print（）;
cout<l1.destroy（）;
cout<<"奇数项为：
";
l2.print（）;
cout<l2.destroy（）;
break;
case11:
//求两个递增有序单链表L1和L2中的公共元素
cout<<"请输入单链表L1中元素（9999退出）：
"<l1.create_r（）;
cout<<"请输入单链表L2中元素（9999退出）：
"<l2.create_r（）;
l3.interset（l1,l2,l3）;
cout<<"L1和L2中的公共元素为：
";
l3.print（）;
cout<break;
case12:
//删除递增有序单链表中的重复元素
cout<<"请输入单链表中元素（9999退出）：
"<l.create_r（）;
l.delete1（）;
cout<<"删除重复元素后的单链表为：
"<l.print（）;
cout<break;
}
}while（nChoice!
=0）;
return0;
}
#include"iostream.h"
typedefintelementtype;
typedefstructLNode
{
elementtypedata;
structLNode*next;
}node;
classlist
{
public:
list（）;
intlength（）const;
voiddestroy（）;
voidcreate_r（）;
voidcreate_h（）;
boolget_element（constinti,elementtype&x）const;
node*locate（constelementtypex）const;
boolinsert（constinti,constelementtypex）;
booldelete_element（constinti）;
node*get_head（）{returnhead;}
intprint（）;
voidinsert1（constelementtypey）;
voiddivision（listl,list&a,list&b）;
voidinterset（lista,listb,list&c）;
booldelete1（）;
private:
intcount;
node*head;
};
//表尾插入法建表
voidlist:
:
create_r（）
{
elementtypex;
cin>>x;
node*rear=head;
while（x!
=9999）
{
count++;
node*s=newnode;
s->data=x;
rear->next=s;
rear=s;
rear->next=NULL;
cin>>x;
}
}
//表头插入法建立链表
voidlist:
:
create_h（）
{
elementtypex;
node*s=newnode;
cin>>x;
while（x!
=9999）
{
count++;
s=newnode;
s->data=x;
s->next=head->next;
head->next=s;
cin>>x;
}
}
//
list:
:
list（）
{
head=newnode;
head->next=NULL;
count=0;
}
intlist:
:
length（）const
{returncount;}
voidlist:
:
destroy（）
{
node*p,*u;
p=head;//p指向头结点
while（p）
{
u=p->next;//取得下一个结点指针
deletep;//删除当前结点
p=u;//p指向下一个结点
}
head=NULL;//头指针置空
cout<<"单链表已销毁"<}
boollist:
:
get_element（constinti,elementtype&x）const
{
node*p=newnode;
p=head->next;
intj=1;
while（p!
=NULL&&j!
=1）
{
p=p->next;
j++;
}
if（p==NULL）returnfalse;
x=p->data;
returntrue;
}
//查找运算
node*list:
:
locate（constelementtypex）const
{
node*p=newnode;
p=head->next;
while（p!
=NULL）
{if（p->data==x）returnp;
elsep=p->next;
}
returnNULL;
}
//插入算法
boollist:
:
insert（constinti,constelementtypex）
{
node*p=newnode;
p=head;
intj=0;
while（j!
=i-1&&p!
=NULL）
{
p=p->next;
j++;
}
if（i<1||i>count+1）
returnfalse;
node*s=newnode;
s->data=x;
s->next=p->next;
p->next=s;
count++;
returntrue;
}
//删除运算
boollist:
:
delete_element（constinti）
{
node*p=newnode;
node*u=newnode;
intj=0;
p=head->next;
while（j!
=i-1&&p!
=NULL）
{
p=p->next;
j++;
}
if（i<1||i>count）
returnfalse;
u=p->next;
p->next=u->next;
deleteu;
count--;
returntrue;
}
intlist:
:
print（）
{
node*p=newnode;
p=head->next;
while（p）
{
cout<data<<"\t";
p=p->next;
}
returnNULL;
}
//递增有序单链表中插入元素，并保持递增有序性
voidlist:
:
insert1（constelementtypey）
{
node*p=newnode;
p=head->next;
while（p->data<=y）
p=p->next;
node*u=newnode;
u->data=p->data;
p->data=y;
u->next=p->next;
p->next=u;
count++;
}
//将链表l中的奇偶数项节点分解开并分别放入两个链表中
voidlist:
:
division（listl,list&a,list&b）
{
node*p=newnode;
p=l.head->next;
node*rear,*rear1;
rear=a.get_head（）;
rear1=b.get_head（）;
while（p!
=NULL）
{
if（p->data%2==0）
{
a.count++;
node*m=newnode;
m->data=p->data;
rear->next=m;
rear=m;
rear->next=NULL;
}
else
{
b.count++;
node*n=newnode;
n->data=p->data;
rear1->next=n;
rear1=n;
rear1->next=NULL;
}
p=p->next;
}
}
//将两个递增有序单链表L1和L2中的公共元素，放入新的单链表L3中
voidlist:
:
interset（lista,listb,list&c）
{
node*pa,*pb,*rc,*u;
rc=c.get_head（）;
pa=a.get_head（）->next;
pb=b.get_head（）->next;
while（pa!
=NULL&&pb!
=NULL）
{
if（pa->datadata）pa=pa->next;
elseif（pa->data>pb->data）pb=pb->next;
else{
u=newnode;
u->data=pa->data;
rc->next=u;
rc=u;
c.count++;
pa=pa->next;
pb=pb->next;
}
}
rc->next=NULL;
}
//删除递增有序单链表中的重复元素
boollist:
:
delete1（）
{
node*p=head->next;
if（p==NULL）returnfalse;
while（p->next!
=NULL）
{
if（p->data==p->next->data）
{
node*u=newnode;
u=p->next;
p->next=u->next;
deleteu;
count--;
}
elsep=p->next;
}
returntrue;
}
升级会员 