数据结构线性表应用.docx

数据结构线性表应用.docx

《数据结构线性表应用.docx》由会员分享，可在线阅读，更多相关《数据结构线性表应用.docx（24页珍藏版）》请在冰豆网上搜索。

数据结构线性表应用

实验一线性表应用

一.实验目的

1、掌握用TurboC或VC++上机调试线性表的基本方法；

2、掌握线性表的基本操作，如插入、删除、查找，以及线性表合并等运算在顺序存储结构和链式存储结构上的运算；并能够运用线性表基本操作解决问题，实现相应算法。

二.实验学时：

课内实验学时：

2学时

课外实验学时：

4学时

三．备选实验题目

1．单链表基本操作练习（实验类型：

验证型）

1）问题描述：

在主程序中设计一个简单的菜单，分别调用相应的函数功能：

1…建立链表

2…连接链表

3…输出链表

0…结束

2）实验要求：

在程序中定义下述函数，并实现所要求的函数功能：

CreateLinklist（）:

从键盘输入数据，创建一个单链表

ContLinklist（）：

将前面建立的两个单链表首尾相连

OutputLinklist（）：

输出显示单链表

3）实验提示:

✧单链表数据类型定义（C语言）

#include

typedefintElemType；//元素类型

typedefstructLNode

{ElemTypedata;

structLNode*next;

}LNode,*LinkList;

✧为了算法实现简单，最好采用带头结点的单向链表。

4）注意问题:

✧重点理解链式存储的特点及指针的含义。

✧注意比较顺序存储与链式存储的各自特点。

✧注意比较带头结点、无头结点链表实现插入、删除算法时的区别。

✧单链表的操作是数据结构的基础，一定要注意对这部分的常见算法的理解。

2．顺序表基本操作练习（实验类型：

验证型）

1）问题描述：

✧从键盘输入一组整型元素序列，建立顺序表。

✧实现该顺序表的遍历。

✧在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。

✧判断该顺序表中元素是否对称,对称返回1,否则返回0。

2）实验要求：

✧对应问题描述，在程序中定义4个相应的函数，实现上面要求的函数功能：

✧在主程序中设计一个简单的菜单，调用上述4个函数

3）实验提示:

✧顺序表存储数据类型定义（C语言）

#defineMAXSIZE100//表中元素的最大个数

typedefintElemType；//元素类型

typedefstructlist{

ElemTypeelem[MAXSIZE];//静态线性表

intlength;//表的实际长度

}SqList;//顺序表的类型名

4）注意问题:

✧插入、删除时元素的移动原因、方向及先后顺序。

✧理解不同的函数形参与实参的传递关系。

3．约瑟夫环问题（实验类型：

综合型）

1）问题描述：

有编号为1,2…n的n个人按顺时针方向围坐一圈，每人持有一个正整数密码。

开始给定一个正整数m，从第一个人按顺时针方向自1开始报数，报到m者出列，不再参加报数，这时将出列者的密码作为m，从出列者顺时针方向的下一人开始重新自1开始报数。

如此下去，直到所有人都出列。

试设计算法，输出出列者的序列。

2）实验要求:

采用顺序和链式两种存储结构实现

3）实现提示：

✧用顺序表来存储围座者的序号和密码（顺序存储结构）.

⏹用number和code分别表示围座者的序号和密码.假设围座者人数为j,当前使用密码为m,开始报数者位置为s,那么下一出列者位置为s=（s+m-1）modj.

⏹当我们要在线性表的顺序存储结构上的第i个位置上插入一个元素时，必须先将线性表的第i个元素之后的所有元素依次后移一个位置，以便腾空一个位置，再把新元素插入到该位置。

若要删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置。

✧用链式存储解决此问题时可以采用循环链表.

4）注意问题:

✧顺序存储和链式存储实现此算法时计算出列位置的不同方法，人员出列后所做操作的区别。

4．一元稀疏多项式简单的计算器（实验类型：

综合型）

1）问题描述：

用线性表表示一元稀疏多项式，设计一个一元多项式运算器

2）实验要求:

✧采用单链表存储结构一元稀疏多项式

✧输入并建立多项式

✧输出多项式

✧实现多项式加、减运算

3）实现提示：

以两个多项式相加为例

✧结果多项式另存

✧扫描两个相加多项式，若都未检测完：

⏹若当前被检测项指数相等，系数相加，若结果未变成0，则将结果插入到结果多项式。

⏹若当前被检测项指数不等，则将指数较小者插入到结果多项式。

✧若有一个多项式已检测完，则将另一个多项式剩余部分直接连接到结果多项式。

5．长整数（任意长度）四则运算演示程序（实验类型：

综合型）

1）问题描述：

设计一个实现任意长的整数进行加法运算的演示程序

2）实验要求:

✧利用双向循环链表实现长整数的存储，给各结点含一个整型变量。

任何整型变量的的范围是-（215-1）~（215-1）。

✧输入和输出形式：

按照中国对长整数的表示习惯，每四位一组，组间用逗号隔开。

3）实现提示：

✧每个结点中可以存放的最大整数为215-1=32767，才能保证两数相加不会溢出。

但若这样存，即相当于按32768进制数存，在十进制数与32768进制数之间的转换十分不方便。

故可以在每个结点中仅存十进制数的4位，即不超过9999的非负整数，整个链表视为万进制数。

✧可以利用头结点数据域的符号代表长整数的符号。

用其绝对值表示元素结点的树木。

相加过程中不要破坏两个操作数链表。

两操作数的头指针存于指针数组中是简化程序结构的一种方法。

4）注意问题:

✧不能给常整数位数规定上限。

程序设计源代码如下：

第一题：

#include

#include

#include

typedefintElemType;////元素类型

typedefstructLNode

{

ElemTypedata;

structLNode*next;

}LNode;

typedefLNode*LinkList;

LinkListhead;

LinkListL;////定义单链表头指针L

LinkListL1;

LinkListL2;

LinkListL12;

LinkListCreatlist_L（）///////尾插入法建立单链表

{

LinkListL,p,r;

intx;

r=L=（LinkList）malloc（sizeof（LNode））;

L->next=NULL;

cin>>x;

while（x!

=0）

{

p=（LinkList）malloc（sizeof（LNode））;

p->data=x;

p->next=NULL;

r->next=p;

r=p;

cin>>x;

}

returnL;

}

LinkListShow_L（LinkListL）

{

LinkListp2;

p2=L;

while（p2->next!

=NULL）

{

cout<next->data<<"";

p2=p2->next;

}

returnL;

}

LinkListContlist_L（LinkListA,LinkListB）

{

LinkListC,a,b,e,f;

a=A->next;

b=B->next;

C=A;////C表的头节点

f=C=（LinkList）malloc（sizeof（LNode））;

C->next=NULL;//////建立空链表

while（a）

{

e=（LinkList）malloc（sizeof（LNode））;

e->data=a->data;

e->next=NULL;

f->next=e;

f=e;

a=a->next;

}

while（b）

{

e=（LinkList）malloc（sizeof（LNode））;

e->data=b->data;

e->next=NULL;

f->next=e;

f=e;

b=b->next;

}

returnC;

}

voidmain（）

{

intchoice;

for（;;）

{

cout<<"+++++++++++++进入菜单+++++++++++++:

"<

cout<<"1.建立单链表:

"<

cout<<"2.连接单链表:

"<

cout<<"3.输出单链表:

"<

cout<<"0.程序结束:

"<

cout<

cout<<"请选择操作序号:

"<

cin>>choice;

if（choice==0）

{

cout<<"成绩结束，任意键退出！

"<

break;

}

switch（choice）

{

case1:

{

intchoice1;

cout<<"开始建立单链表1:

"<

L1=Creatlist_L（）;

cout<

cout<<"表1建立完毕!

"<

cout<<"是否继续建立单链表2？

"<<"\n1.继续2.返回"<

cin>>choice1;

if（choice1==1）

{

cout<<"开始建立单链表2"<

L2=Creatlist_L（）;

cout<

cout<<"表2建立完毕!

"<

}

cout<

cout<<"单链表建立完毕!

!

"<

break;

}

case2:

{

cout<<"开始连接单链表1，2!

"<

L12=Contlist_L（L1,L2）;

cout<<"asfsdfsagshdfhgdfhjdfhhdfhasdf"<

break;

}

case3:

{

intchoice1;

cout<<"请选择输出哪个表：

"<

cout<<"1.表12.表23.联立后的表12"<

cin>>choice1;

switch（choice1）

{

case1:

{

cout<<"单链表1为：

"<

Show_L（L1）;

cout<

break;

}

case2:

{

cout<<"单链表2为：

"<

Show_L（L2）;

cout<

break;

}

case3:

{

cout<<"联立后的表12为:

"<

Show_L（L12）;

cout<

break;

}

}

break;

}

}

}

}

第二题：

#include

#include

#include

#defineMaxsize100//表中元素的最大个数

typedefintElemType;//元素类型

typedefstructlist

{

ElemTypedata[Maxsize];//静态线性表

intlength;//表的实际长度

}SqList;//顺序表的类型名

intm=0;

SqList*creat_SqList（SqList*L）/////建立线性表，并输入线性表元素

{

L=（SqList*）malloc（sizeof（SqList））;

cout<<"请输入线性表数据:

"<

for（m;;m++）

{

ElemTypex;

cin>>x;

if（x==0）

break;

L->data[m]=x;

}

L->length=m;

returnL;

}

SqList*all_SqList（SqList*L）

{

cout<<"已建立的线性表为:

"<

for（inti=0;ilength;i++）

{

cout<data[i]<<"";

}

cout<

returnL;

}

intserch_SqList（SqList*L,inty）////查询元素函数

{

for（intj=0;jlength;j++）

{

if（L->data[j]==y）

{

cout<<"表中含有此数据，位于表中第"<

"<

return1;

break;

}

elseif（j==L->length-1）

{

cout<<"表中没有此数据!

"<

break;

}

else

continue;

}

}

voidjudje_SqList（SqList*L）////判断是否对称函数

{

if（m%2==0）/////线性表元素个数为偶数个

{

cout<<"中心元素为"<data[m/2]<

for（intk=0;k<=m/2+1;k++）

{

if（k==m/2+1）

{

cout<<"*****该线性表对称!

*****"<

break;

}

elseif（L->data[k]==L->data[m-1-k]）

continue;

else

{

cout<<"*****该线性表不是对称的!

*****"<

break;

}

}

}

else/////////////线性表元素个数为奇数个

{

cout<<"中心元素为"<data[m/2]<

for（intt=0;t<=m/2+1;t++）

{

if（t==m/2+1）

{

cout<<"*****该线性表对称!

*****"<

break;

}

elseif（L->data[t]==L->data[m-1-t]）

continue;

else

{

cout<<"*****该线性表不是对称的!

*****"<

break;

}

}

}

}

intmain（）

{

SqList*L1;

intchoice;

for（;;）

{

cout<<"++++++++++++主菜单+++++++++++++"<

cout<<"1.新建线性表;"<

cout<<"2.遍历线性表;"<

cout<<"3.查找表中元素;"<

cout<<"4.判断是否对称;"<

cout<<"0.退出程序;"<

cout<

cout<<"请输入操作序号：

"<

cin>>choice;

if（choice==0）break;

switch（choice）

{

case1:

{

L1=creat_SqList（L1）;

cout<<"线性表长度为:

"<

break;

}

case2:

{

cout<<"开始遍历线性表：

"<

all_SqList（L1）;

break;

}

case3:

{

inty;

cout<<"请输入要查找的元素：

"<

cin>>y;

serch_SqList（L1,y）;

break;

}

case4:

{

cout<<"正在检测是否对称!

"<

judje_SqList（L1）;

break;

}

}

}

return0;

}

第三题：

#include

#include

#include

#defineMaxsize50//元素最大容量

typedefintElemType;//元素类型

typedefstructlist

{

ElemTypenum[Maxsize];

ElemTypecode[Maxsize];

intlength;//表的实际长度

}Juserfu;//顺序表的类型名

JuserfuL;//定义一个顺序表L

intj=0;//围坐的总人数

Juserfu*creat_Juserfu（Juserfu*L）/////建立线性表，并输入线性表元素

{

L=（Juserfu*）malloc（sizeof（Juserfu））;

cout<<"请分别输入每个人的序号和密码:

"<

for（j;;j++）

{

ElemTypem,s;//定义密码

cin>>s>>m;

if（m==0）

break;

L->num[j]=s;

L->code[j]=m;

}

L->length=j;

returnL;

}

Juserfu*output_Juserfu（Juserfu*L）//输出出列者的序列

{

intx_num=0;

intx_code;

cout<<"请输入初始密码：

"<

cin>>x_code;

for（j;j>0;j--）

{

x_num=（x_num+x_code-1）%j;

cout<num[x_num]<<"号！

"<

x_code=L->code[x_num];

for（x_num;x_num

{

L->num[x_num]=L->num[x_num+1];

L->code[x_num]=L->code[x_num+1];

}

}

returnL;

}

voidmain（）

{

//ints;

Juserfu*L1;

cout<<"请输入每位围坐者的密码!

"<

L1=creat_Juserfu（L1）;

cout<<"共围坐人数为：

"<length<

cout<<"密码分别为：

"<

for（inti=0;i

{

cout<num[i]<<""<code[i]<<"";

}

output_Juserfu（L1）;

}

第四题：

#include

#include

#include

typedefstructPolyNode{

floatcoef;//系数

floatexp;//指数

PolyNode*next;//指针域

}PolyNode;

typedefPolyNode*Polynomial;

PolynomialA;//定义多项式A

Polynomialcreat_Poly（）

{

PolynomialL,p,r;

floatx_coef;

floatx_exp;

r=L=（Polynomial）malloc（sizeof（PolyNode））;

L->next=NULL;

cout<<"请依次输入多项式的系数和指数（0,0为输入结束）：

"<

cin>>x_coef>>x_exp;

while（x_coef!

=0&&x_exp!

=0）

{

p=（Polynomial）malloc（sizeof（PolyNode））;

p->coef=x_coef;

p->exp=x_exp;

p->next=NULL;

r->next=p;

r=p;

cin>>x_coef>>x_exp;

}

returnL;

}

Polynomialshow_Poly（PolynomialL）

{

Polynomialp1;

p1=L;

while（p1->next!

=NULL）

{

cout<next->coef<<"X"<next->exp<<"+";

p1=p1->next;

}

cout<

returnL;

}

Polynomialadd_Poly（PolynomialA,PolynomialB）

{

PolynomialC,D;

Polynomialp1,p2,p3;

floatsum;

p1=A->next;

p2=B->next;

C=（Polynomial）malloc（sizeof（PolyNode））;

p3=C;

p3->next=NULL;

while（p1&&p2）

{

if（p1->exp==p2->exp）

{

sum=p1->coef+p2->coef;

if（sum!

=0）

{

D=（Polynomial）malloc（sizeof（PolyNode））;

D->coef=sum;

D->exp=p1->exp;

D->next=NULL;

p3->next=D;

p3=D;

}

p1=p1->next;

p2=p2->next;

}

elseif（p1->expexp）

{

D=（Poly