数据结构实验报告三线性表的链式存储.docx

数据结构实验报告三线性表的链式存储.docx

《数据结构实验报告三线性表的链式存储.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告三线性表的链式存储.docx（18页珍藏版）》请在冰豆网上搜索。

数据结构实验报告三线性表的链式存储

实验报告三线性表的链式存储

班级：

2010XXX姓名：

HoogLe学号：

2010XXXX专业：

XXXX

2858505197@

一、实验目的：

（1）掌握单链表的基本操作的实现方法。

（2）掌握循环单链表的基本操作实现。

（3）掌握两有序链表的归并操作算法。

二、实验内容：

（请采用模板类及模板函数实现）

1、线性表链式存储结构及基本操作算法实现

[实现提示]（同时可参见教材p64-p73页的ADT描述及算法实现及ppt）函数、类名称等可自定义，部分变量请加上学号后3位。

也可自行对类中所定义的操作进行扩展。

所加载的库函数或常量定义：

#include

usingnamespacestd;

（1）单链表存储结构类的定义：

template

classLinkList{

public:

LinkList（）;//初始化带头结点空单链表构造函数实现

LinkList（Ta[],intn）;//利用数组初始化带头结点的单链表构造函数实现

~LinkList（）;

intlength（）;//求单链表表长算法

Tget（inti）;//获得单链表中第i个结点的值算法

intlocate（Ttemp）;

voidinsert（inti,Ttemp）;//在带头结点单链表的第i个位置前插入元素e算法

TDelete（inti）;//在带头结点单链表中删除第i个元素算法

voidprint（）;//遍历单链表元素算法

boolisEmpty（）;//判单链表表空算法

voiddeleleAll（）;//删除链表中所有结点算法（这里不是析构函数，但功能相同）

private:

Node*head;

};

（2）初始化带头结点空单链表构造函数实现

输入：

无

前置条件：

无

动作：

初始化一个带头结点的空链表

输出：

无

后置条件：

头指针指向头结点。

//初始化带头结点空单链表构造函数实现

template

LinkList:

:

LinkList（）{

head=newNode;

head->next=NULL;

}

（３）利用数组初始化带头结点的单链表构造函数实现

输入：

已存储数据的数组及数组中元素的个数

前置条件：

无

动作：

利用头插或尾插法创建带头结点的单链表

输出：

无

后置条件：

头指针指向头结点，且数组中的元素为链表中各结点的数据成员。

//利用数组初始化带头结点的单链表构造函数实现

template

LinkList:

:

LinkList（Ta[],intn）{

head=newNode;

head->next=NULL;

for（inti=0;i

{

Node*s=newNode;

s->data=a[i];

s->next=head->next;

head->next=s;

}

}

（４）在带头结点单链表的第i个位置前插入元素e算法

输入：

插入位置i，待插入元素e

前置条件：

i的值要合法

动作：

在带头结点的单链表中第i个位置之前插入元素e

输出：

无

后置条件：

单链表中增加了一个结点

//在带头结点单链表的第i个位置前插入元素e算法

template

voidLinkList:

:

insert（inti,Ttemp）{

Node*p=head;

intcount=0;

while（p&&count

{

p=p->next;

count++;

}

if（p==NULL）cout<<"i不合法，越界!

";

else{

Node*s=newNode;

s->data=temp;

s->next=p->next;

p->next=s;

}

}

（５）在带头结点单链表中删除第i个元素算法

输入：

删除第i个结点，待存放删除结点值变量e

前置条件：

单链表不空，i的值要合法

动作：

在带头结点的单链表中删除第i个结点，并返回该结点的值（由e传出）。

输出：

无

后置条件：

单链表中减少了一个结点

//在带头结点单链表中删除第i个元素算法

template

TLinkList:

:

Delete（inti）{

Node*p=head;

intcount=0;

while（p&&count

p=p->next;

count++;

}

if（p==NULL）cout<<"i不合法，越界!

";

else{

Node*s=p->next;

Tx=s->data;

p->next=s->next;

returnx;

}

}

（６）遍历单链表元素算法

输入：

无

前置条件：

单链表不空

动作：

遍历输出单链表中的各元素。

输出：

无

后置条件：

无

//遍历单链表元素算法

template

voidLinkList:

:

print（）{

Node*p=head->next;

while（p）{

cout<data<<"";

p=p->next;

}

cout<

}

（７）求单链表表长算法。

输入：

无

前置条件：

无

动作：

求单链表中元素个数。

输出：

返回元素个数

后置条件：

无

//求单链表表长算法

template

intLinkList:

:

length（）{

Node*p=head;

intcount=0;

while（p）{

p=p->next;

count++;

}

return--count;

}

（８）判单链表表空算法

输入：

无

前置条件：

无

动作：

判表是否为空。

输出：

为空时返回１，不为空时返回0

后置条件：

无

//判断非空

template

boolLinkList:

:

isEmpty（）{

Node*p=head->next;

if（p）returntrue;

elsereturnfalse;

}

（９）获得单链表中第i个结点的值算法

输入：

无

前置条件：

i不空，i合法

动作：

找到第i个结点。

输出：

返回第i个结点的元素值。

后置条件：

无

//获得单链表中第i个结点的值算法

template

TLinkList:

:

get（inti）{

Node*p=head;

intcount=0;

while（p&&count

p=p->next;

count++;

}

if（p==NULL）cout<<"i不合法，越界!

";

else{

returnp->data;

}

}

（10）删除链表中所有结点算法（这里不是析构函数，但功能相同）

输入：

无

前置条件：

单链表存在

动作：

清除单链表中所有的结点。

输出：

无

后置条件：

头指针指向空

//删除所有元素

template

voidLinkList:

:

deleleAll（）{

Node*p=head;

while（p）

{

Node*t=p;

p=p->next;

t->next=NULL;

}

}

（11）上机实现以上基本操作，写出main（）程序：

参考p72

voidmain（）{

inta[10]={1,2,3,4,5,6,7,8,9,0};

//测试带参数的构造函数（前端插入！

）

LinkListlist1（a,10）;

//测试插入

if（list1.isEmpty（））{

cout<<"链表不为空!

"<

}

else{

cout<<"链表为空!

"<

}

list1.print（）;

cout<<"测试插入"<

list1.insert（5,20）;

list1.print（）;

cout<<"测试表长"<

cout<

cout<<"测试删除"<

cout<

list1.print（）;

cout<<"测试得到第5个元素"<

cout<

cout<<"测试删除所有元素!

"<

list1.deleleAll（）;

list1.print（）;

}

粘贴测试数据及运行结果：

2、参考单链表操作定义与实现，自行完成单循环链表的类的定义与相操作操作算法。

template

classLinkList{

public:

LinkList（Ta[],intn）;//利用数组初始化带头结点的单循环链表构造函数实现

voidinsert（inti,Ttemp）;//在带头结点单循环链表的第i个位置前插入元素e算法

TDelete（inti）;//在带头结点单循环链表中删除第i个元素算法

voidprint（）;//遍历单循环链表元素算法

private:

Node*head;

intlength;

};

（１）利用数组初始化带头结点的单循环链表构造函数实现

输入：

已存储数据的数组及数组中元素的个数

前置条件：

无

动作：

利用头插或尾插法创建带头结点的单循环链表

输出：

无

后置条件：

头指针指向头结点，且数组中的元素为链表中各结点的数据成员，尾指针指向头结点。

//利用数组初始化带头结点的单循环链表构造函数实现

template

LinkList:

:

LinkList（Ta[],intn）{

head=newNode;

head->next=head;

length=0;

for（inti=0;i

{

Node*s=newNode;

s->data=a[i];

s->next=head->next;

head->next=s;

length++;

}

}

（２）在带头结点单循环链表的第i个位置前插入元素e算法

输入：

插入位置i，待插入元素e

前置条件：

i的值要合法

动作：

在带头结点的单循环链表中第i个位置之前插入元素e

输出：

无

后置条件：

单循环链表中增加了一个结点

//在带头结点单循环链表的第i个位置前插入元素e算法

template

voidLinkList:

:

insert（inti,Ttemp）{

cout<length<

Node*p=head;

intcount=0;

if（i>length）cout<<"i不合法，越界!

";

else{

while（count

p=p->next;

count++;

}

Node*s=newNode;

s->data=temp;

s->next=p->next;

p->next=s;

}

}

（３）在带头结点单循环链表中删除第i个元素算法

输入：

删除第i个结点，待存放删除结点值变量e

前置条件：

单循环链表不空，i的值要合法

动作：

在带头结点的单循环链表中删除第i个结点，并返回该结点的值（由e传出）。

输出：

无

后置条件：

单循环链表中减少了一个结点

//在带头结点单循环链表中删除第i个元素算法

template

TLinkList:

:

Delete（inti）{

Node*p=head;

intcount=0;

if（i>length）cout<<"i不合法，越界!

"<

else{

while（count

p=p->next;

count++;

}

Node*s=p->next;

Tx=s->data;

p->next=s->next;

returnx;

}

}

（４）遍历单循环链表元素算法

输入：

无

前置条件：

单循环链表不空

动作：

遍历输出单循环链表中的各元素。

输出：

无

后置条件：

无

//遍历单循环链表元素算法

template

voidLinkList:

:

print（）{

Node*p=head->next;

while（p!

=head）{

cout<data<<"";

p=p->next;

}

cout<

}

（５）上机实现以上基本操作，写出main（）程序：

voidmain（）{

inta[10]={1,2,3,4,5,6,7,8,9,0};

//测试带参数的构造函数（前端插入！

）

LinkListlist1（a,10）;

list1.print（）;

cout<<"测试插入"<

list1.insert（5,20）;

list1.print（）;

cout<<"测试删除操作"<

list1.Delete（5）;

list1.print（）;

}

粘贴测试数据及运行结果：

３、采用链式存储方式，并利用单链表类及类中所定义的算法加以实现线性表La,Lb为非递减的有序线性表，将其归并为新线性表Lc，该线性表仍有序（未考虑相同时删除一重复值）的算法。

模板函数：

template

voidLinkList:

:

addtwo（LinkListLa,LinkListLb）{

Node*p1=La.head->next;

Node*p2=Lb.head->next;

intnum=0;

while（p1&&p2）{

if（p1->data>p2->data）

{

this->insert（++num,p1->data）;

p1=p1->next;

}

else{

this->insert（++num,p2->data）;

p2=p2->next;

}

}

if（!

p1）

{

p1=p2;

}

while（p1）{

this->insert（++num,p1->data）;

p1=p1->next;

}

}

voidmain（）{

inta[5]={1,2,5,6,9};

intb[5]={0,3,4,7,8};

LinkListlist1（a,5）;

LinkListlist2（b,5）;

list1.print（）;

list2.print（）;

LinkListlist3;

list3.addtwo（list1,list2）;

list3.print（）;

system（"pause"）;

}

粘贴测试数据及运行结果：

选做题：

１、按一元多项式ADT的定义，实现相关操作算法：

ADTPNodeis

Data

系数（coef）

指数（exp）

指针域（next）:

指向下一个结点

Operation

暂无

endADTPNode

ADTPolynomialis

Data

PNode类型的头指针。

Operation　

　Polynomail

初始化值：

无

　动作：

申请头结点，由头指针指向该头结点，并输入m项的系数和指数，建立一元多项式。

　DestroyPolyn

输入：

无

前置条件：

多项式已存在

动作：

消毁多项式。

输出：

无

后置条件：

头指针指向空

　PolyDisplay

输入：

无

前置条件：

多项式已存在，不为空

动作：

输出多项式各项系数与指数

输出：

无

后置条件：

无

AddPoly

输入：

另一个待加的多项式

前置条件：

一元多项式pa和pb已存在。

动作及后置条件：

完成多项式相加运算，（采用pa=pa+pb形式,并销毁一元多项式pb）

输出：

无

endADTPolynomial

２、实现一元多项式的减法，操作描述如下：

SubPoly

输入：

待减的多项式pb

前置条件：

一元多项式pa和pb已存在。

动作及后置条件：

完成多项式减法运算，即：

pa=pa-pb,并销毁一元多项式pb。

输出：

无

３、参考P74-P79页双向链表的存储结构定义及算法，编程实现双向链表的插入算法和删除算法。

三、心得体会：

（含上机中所遇问题的解决办法，所使用到的编程技巧、创新点及编程的心得）