单链表实验报告.docx

单链表实验报告.docx

《单链表实验报告.docx》由会员分享，可在线阅读，更多相关《单链表实验报告.docx（12页珍藏版）》请在冰豆网上搜索。

单链表实验报告

单链表实验报告

实验目的：

1）理解线性表的链式存储结构；

2）熟练掌握动态链表结构及有关算法的设计；

3）根据具体问题的需要，设计出合理的表示数据的链表结构，并设计相关算法。

实验要求：

实验环境：

visualc++6.0

实验内容及数据：

1）求链表中第i个结点的指针（函数），若不存在，则返回NULL。

实验测试数据基本要求：

第一组数据：

链表长度n≥10，i分别为5，n，0，n+1，n+2

第二组数据：

链表长度n=0，i分别为0，2

2）在第i个结点前插入值为x的结点。

实验测试数据基本要求：

第一组数据：

链表长度n≥10，x=100,i分别为5，n，n+1，0，1，n+2

第二组数据：

链表长度n=0，x=100，i=5

3）删除链表中第i个元素结点。

实验测试数据基本要求：

第一组数据：

链表长度n≥10，i分别为5，n，1，n+1，0

第二组数据：

链表长度n=0，i=5

4）在一个递增有序的链表L中插入一个值为x的元素，并保持其递增

有序特性。

实验测试数据基本要求：

链表元素为（10,20,30,40,50,60,70,80,90,100）,

x分别为25，85，110和8

5）将单链表Ｌ中的奇数项和偶数项结点分解开，并分别连成一个带头结点的单链表，然后再将这两个新链表同时输出在屏幕上，并保留原链表的显示结果，以便对照求解结果。

实验测试数据基本要求：

第一组数据：

链表元素为（1，2，3，4，5，6，7，8，9，10，20，

30，40，50，60）

第二组数据：

链表元素为（10，20，30，40，50，60，70，80，

90，100）

6）求两个递增有序链表L1和L2中的公共元素，并以同样方式连接成

链表L3。

实验测试数据基本要求：

第一组

第一个链表元素为（1，3，6，10，15，16，17，18，19，20）

第二个链表元素为（1，2，3，4，5，6，7，8，9，10，18，20，

30）

第二组

第一个链表元素为（1，3，6，10，15，16，17，18，19，20）

第二个链表元素为（2，4，5，7，8，9，12，22）

第三组

第一个链表元素为（）

第二个链表元素为（1，2，3，4，5，6，7，8，9，10）

实验准备：

1）

求第i个节点指针：

先设一指针p，使其初值为头节点的下一指针及p=head.next,并设置一变量j作为记录节点的序号，利用循环先从头节点依次指向所数到的节点，循环条件要考虑到节点不存在的情况。

while（j!

=i&&p!

=NULL）{

p=p.next;j++;returnp;}

2）在第i个结点前插入值为x的结点

首先搜索到插入的位置，然后产生节点，将x装入，将产生的节点的后继指针指向该位置的下一节点，并将该位置前一节点后继指针指向产生的节点考虑i是否满足插入条件。

while（j!

=i-1&&p!

=NULL）{p=p.next;j++;}

else{s=newnode;s.data=x;s.next=p.next;p.next=s（指向产生的节点）

;}

3）删除链表中第i个元素结点

和插入类似，明确删除的节点，将该节点前一节点后继指针指向该节点的后继指针所指节点，然后删除该节点。

p指向i的前一节点u=p.next;p.next=u.next;deleteu;

4）在一个递增有序的链表L中插入一个值为x的元素，并保持其递增

有序特性。

和插入类似，先将x与表中每一元素比较，当x<=L.data时，建立节点插入该节点之前。

当指针为空时插入表尾。

5）将单链表Ｌ中的奇数项和偶数项结点分解开，并分别连成一个带头

结点的单链表，然后再将这两个新链表同时输出在屏幕上，并保留

原链表的显示结果，以便对照求解结果

先建立两个空链表A，B，与插入类似，使p=L.next开始，当序号

i为奇数插入A，否则插入B，到p==NULL;m=A.next;n=B.next;利

用循环cout<

况

6）求两个递增有序链表L1和L2中的公共元素，并以同样方式连接成

链表L3。

建一新表，考虑递增这一条件。

设置两指针p1,p2,分别指向两表

A,B.初值为A.next,B.next.

1.p1.data==p2.data,则插入新表。

将p1,p2后移。

2.p1.data〉p2.data，将p2后移，继续查找。

3.p1.data

反复执行比较，直到其中一表为空结束。

实验程序：

#include

#include

typedefintelementtype;

structNode

{

elementtypedata;

Node*next;

};

classlist

{

private:

Node*head;

Node*real;

public:

list（）;

Node*first（inti）;

voidsecond（inti,elementtypex）;

voidthird（inti）;

voidforth（elementtypex）;

//

voidfifth（list&L2,list&L3）;

voidsixth（list&L1,list&L2）;

voidcreat（）;

friendostream&operator<<（ostream&out,list&L）;

};

list:

:

list（）

{

head=newNode;

real=head;

}

voidlist:

:

creat（）/

{

Node*u;

elementtypex;

cin>>x;

while（x!

=-1）

{

u=newNode;

u->data=x;

real->next=u;

real=u;

cin>>x;

}

real->next=NULL;

}

ostream&operator<<（ostream&out,list&L）

{

Node*p=L.head->next;

while（p!

=NULL）

{

out<data;

p=p->next;

out<<"";

}

out<<"";

returnout;

}

Node*list:

:

first（inti）

{

Node*p=head->next;intj;

while（j!

=i-1&&p!

=NULL）

{p=p->next;j++;}

returnp;

}

voidlist:

:

second（inti,elementtypex）

{

Node*p=head;intk=0;Node*s;

while（k!

=i-1&&p!

=NULL）

{p=p->next;k++;}

if（p==NULL）cerr<<"输入序列号错误";

else{

s=newNode;

s->data=x;

s->next=p->next;

p->next=s;

}

}

voidlist:

:

third（inti）

{

Node*u,*p=head;intk=0;

while（k!

=i-1&&p!

=NULL）

{p=p->next;k++;}

if（p==NULL||p->next==NULL）

cerr<<"输入序列号错误";

else

{

u=p->next;

p->next=u->next;

deleteu;

}

}

voidlist:

:

forth（elementtypex）

{

Node*p=head;Node*s;

while（p!

=NULL）

{

if（xnext->data）break;

p=p->next;

}

s=newNode;

s->data=x;

s->next=p->next;

p->next=s;

}

voidlist:

:

fifth（list&L2,list&L3）

{

Node*u;inti=0;

Node*p=head->next;

for（i=0;p!

=NULL;i++,p=p->next）

{

u=newNode;u->data=p->data;

if（i%2==0）

{

L2.real->next=u;L2.real=u;

}

else

{

L3.real->next=u;L3.real=u;

}

L2.real->next=NULL;

L3.real->next=NULL;

}

}

voidlist:

:

sixth（list&L1,list&L2）

{

Node*pa,*pb,*u;

pa=L1.head->next;

pb=L2.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;

real->next=u;

real=u;

pa=pa->next;

pb=pb->next;

}

real->next=NULL;

}

}

intmain（）

{

listL1,L2,L3;

intch;inti;elementtypex;

for（;;）

{

cout<<"数据结构实验——单链表"<

cout<<"该实验的目的是根据具体问题的需要，设计出合理的表示数据的链表结构，并设计相关算法";

cout<

cout<<"第1题：

求链表中第i个结点的指针"<

cout<<"第2题：

在第i个结点前插入值为x的结点"<

cout<<"第3题：

删除链表中第i个元素结点"<

cout<<"第4题：

在一个递增有序的链表L中插入一个值为x的元素"<

cout<<"第5题：

将单链表Ｌ中的奇数项和偶数项结点分解开"<

cout<<"第6题：

求两个递增有序链表L1和L2中的公共元素"<

cout<<"退出程序:

0"<

cout<

cout<<"请选择一道题";

cin>>ch;

switch（ch）

{

case1:

{

cout<<"请输入数据，输入-1结束"<

L1.creat（）;

cout<<"请输入结点号i"<>i;

L1.first（i）;

break;

}

case2:

{

cout<<"请输入数据，输入-1结束"<

L1.creat;

cout<

cout<<"请输入结点号i和数据x"<

cin>>i>>x;

L1.second（i,x）;

cout<

break;

}

case3:

{

cout<<"请输入数据，输入-1结束"<

L1.creat（）;

cout<

cout<<"请输入所删除结点号i"<

cin>>i;L1.third（i）;

cout<

break;

}

case4:

{

cout<<"请输入数据，输入-1结束"<

L1.creat（）;

cout<

cout<<"请输入数据x"<

cin>>x;L1.forth（x）;

cout<

break;

}

case5:

{

cout<<"请输入数据，输入-1结束"<

L1.creat（）;

cout<

L1.fifth（L2,L3）;

cout<

cout<

break;

}

case6:

{

cout<<"请输入数据，输入-1结束"<

L1.creat（）;

L2.creat（）;

L3.sixth（L1,L2）;

cout<

cout<

cout<

break;

}

case0:

{

cout<

exit

（1）;

break;

}

default:

{

cout<<"输入错误，请重新选择"<

}

}

}

return0;

}