大数据结构实验报告材料.docx
《大数据结构实验报告材料.docx》由会员分享，可在线阅读，更多相关《大数据结构实验报告材料.docx（43页珍藏版）》请在冰豆网上搜索。
大数据结构实验报告材料
大连海事大学2016-2017-1学期
《数据结构》实验报告
选课序号：
42
班级：
计科
（二）班
学号：
******
姓名：
***
指导教师：
***
成绩：
2016年11月28日
1.实验目的
（1）熟练掌握单循环链表操作的基本算法实现。
（2）熟练掌握串模式匹配算法。
（3）熟练掌握二叉树应用的基本算法实现。
2.实验内容
2.1实验一客房管理（链表）
●实现功能：
以带表头结点的单链表为存储结构，实现如下客房管理的设计要求。
●实验机时：
8
●设计要求：
（1）定义客房链表结点结构类型，以Hotel和*HLink命名，数据域：
客房名称roomN、标准价格Price、入住价格PriceL（默认值=标准价格*80%）、床位数Beds、入住状态State（空闲、入住、预订，默认值为空闲），指针域：
*next；
（2）实现创建客房基本情况链表函数voidBuild（HLink&H），输入客房名称、标准价格、床位数，将入住价格、入住状态修改为默认值，建议用文件操作来输入数据；
（3）实现函数voidupdateH（HLink&H,intbeds,char*state），将床位数为beds的客房入住状态改为state；
（4）实现输出客房基本情况函数voidExp（HLinkH），输出所有客房的客房名称、标准价格、入住价格、床位数、入住状态；
（5）函数voidAdd（HLink&H），将该链表中未入住的客房入住价格均加价20%；
（6）函数voidupBed（HLink&H,intbeds），将该链表床位数不超过beds的结点都放在床位数超过beds的结点后面；
（7）求出入住价格最高的客房函数HLinkFirstH（HLink&H），该函数内return语句返回入住价格最高的客房结点指针，返回前将该结点在链表中删除；
（8）函数voidMoveK1（HLink&H,intk），将单链表中倒数第k个结点移到第一个结点位置，注意：
严禁采用先计算链表长度n再减k（即n-k）的方法；
（9）函数voidReverseN2（HLink&H），将单链表的正中间位置结点之后的全部结点倒置的功能，注意：
严禁采用先计算链表长度n再除以2（即n/2）的方法；
（10）主控函数main（）调用以上函数，输出（3）、（5）、（6）、（7）、（8）、（9）处理后的链表内容、输出入住价格最高的客房基本情况。
可能用到的函数：
从文件中读取客房数据：
fscanf（文件指针,"%s%f,%d",p->roomN,&p->Price,&p->Beds）;
输出客房数据：
printf（"%s%8.1f%8.1f%6d%8s\n",p->roomN,p->Price,p->PriceL,p->Beds,p->State）;
字符串赋值函数：
char*strcpy（char*,constchar*）;
字符串比较函数：
intstrcmp（constchar*,constchar*）
#include
#include
#include
typedefstructHNode//定义客房链表结点结构
{
charroomN[7];//客房名称
floatPrice;//标准价格
floatPriceL;//入住价格（默认值=标准价格*80%）
intBeds;//床位数Beds
charState[5];//入住状态（值域：
"空闲"、"入住"、"预订"，默认值为"空闲"
structHNode*next;//指针域
}Hotel,*HLink;
2.2实验二串模式匹配算法（串）
●实现功能：
从主串中第K个字符起，求出子串在主串中首次出现的位置，即模式匹配或串匹配。
●要求用三种模式匹配算法分别实现：
⏹朴素的模式匹配算法（BF算法）
⏹KMP改进算法（Next[]）
⏹KMP改进算法（NextVal[]）
●实验机时：
6
●设计要求：
首先设计一个含有多个菜单项的主控菜单程序，然后再为这些菜单项配上相应的功能。
程序运行后，给出5个菜单项的内容和输入提示：
1．输入主串、子串和匹配起始位置
2．朴素的模式匹配算法
3．KMP改进算法（Next[]）
4．KMP改进算法（NextVal[]）
0．退出管理系统
请选择0—4：
●菜单设计要求：
使用数字0—4来选择菜单项，其它输入则不起作用。
●输出结果要求：
输出各趟匹配详细过程（其中3、4，首先输出Next[]或者NextVal[]的各元素的数值），最后输出单个字符比较次数、匹配成功时的位置序号或者匹配失败提示信息。
2.3实验三求二叉树上结点的路径（二叉树）
●实现功能：
在采用链式存储结构存储的二叉树上，以bt指向根结点，p指向任一给定的结点，编程实现求出从根结点bt到给定结点p之间的路径。
●实验机时：
6
●设计思路：
数据结构：
typedefstructnode{
chardata;//数据域
structnode*lchild,*rchild;//左右孩子指针
}BinTNode;//树中结点类型
typedefBinTNode*BinTree;
主要实现函数：
⏹二叉树的建立
⏹求指定结点路径
⏹二叉树的前、中、后序遍历算法
⏹查找函数
主控函数及运行环境设置
3.实验步骤
按以上实验内容的要求，给出实验步骤，包括程序流程图、源程序和运行结果截图等。
3.1实验一客房管理（链表）
3.1.1程序流程图
3.1.1源程序
#include
#include
#include
#include
//定义客房链表结点结构
typedefstructHNode
{
charroomN[7];//客房名称
floatPrice;//标准价格
floatPriceL;//入住价格（默认值=标准价格*80%）
intBeds;//床位数Beds
charState[5];//入住状态（值域：
"空闲"、"入住"、"预订"，默认值为"空闲"）
structHNode*next;//指针域
}Hotel,*HLink;
//函数声明
voidBuild（HLink&H）;
voidupdateH（HLink&H,intbeds,charstate[]）;
voidExp（HLinkH）;
voidAdd（HLink&H）;
voidupBed（HLink&H,intbeds）;
HLinkFirstH（HLink&H）;
voidMoveK1（HLink&H,intk）;
voidReverseN2（HLink&H）;
//主函数
voidmain（）
{
HLinkL,h;
intid,k,Beds;
intbeds_num;
charbeds_state[5];
while
（1）{
printf（"\n****************欢迎进入客房信息管理系统******************"）;
printf（"\n\n请查看相关功能，并【!
!
!
按顺序!
!
!
】输入相关功能编号，谢谢！
\n"）;
printf（"*******************************************************************\n"）;
printf（"|1--查看所有客房信息|\n"）;
printf（"|2--更改客房入住状态|\n"）;
printf（"|3--所有未入住客房加价20%%|\n"）;
printf（"|4--更改床号排列顺序|\n"）;
printf（"|5--查找入住价格最高的客房并清空该信息，然后输出更新后信息|\n"）;
printf（"|6--将倒数第K个客房排在首行|\n"）;
printf（"|7--正中间位置结点之后的全部结点倒置后的客房信息|\n"）;
printf（"||\n"）;
printf（"|!
其他---退出|\n"）;
printf（"*******************************************************************\n\n"）;
printf（"!
请选择：
"）;
scanf（"%d",&id）;
if（（id<1）||（id>7））
break;
switch（id）{
case1:
Build（L）;
Exp（L）;
break;
case2:
printf（"\n更改客房入住状态:
\n\n"）;
printf（"输入要更改的床位数：
"）;
scanf（"%d",&beds_num）;
printf（"\n输入要更改的客房状态（空闲、入住、预订）：
"）;
scanf（"%s",beds_state）;
updateH（L,beds_num,beds_state）;
printf（"输出更新后的客房信息\n"）;
Exp（L）;
break;
case3:
printf（"\n!
将该链表中未入住的客房入住价格均加价20%%\n"）;
Add（L）;
printf（"输出加价后的客房信息\n"）;
Exp（L）;
break;
case4:
printf（"输入Beds数：
"）;
scanf（"%d",&Beds）;
upBed（L,Beds）;
Exp（L）;
break;
case5:
h=FirstH（L）;
printf（"\n!
输出入住客房价格最高的客房信息，并删除该节点\n\n"）;
printf（"-------------------------------------------------\n"）;
printf（"客房名称标准价格入住价格床位数入住状态\n"）;
printf（"-------------------------------------------------\n"）;
printf（"%s%8.1f%8.1f%6d%8s\n",h->roomN,h->Price,h->PriceL,h->Beds,h->State）;
printf（"-------------------------------------------------\n\n"）;
printf（"\n\n输出删除后的客房信息\n"）;
Exp（L）;
break;
case6:
printf（"输入K值（1"）;
scanf（"%d",&k）;
MoveK1（L,k）;
Exp（L）;
break;
case7:
printf（"\n输出正中间位置结点之后的全部结点倒置后的客房信息\n"）;
ReverseN2（L）;
Exp（L）;
break;
default:
printf（"!
你输入有误！
\n\n"）;
break;
}
}
}
//正序创建链表：
从键盘输入结点数据
voidBuild（HLink&H）
{
HLinkrear;
HLinkp;
char*indata=".\\studata.txt";//数据输入文件路径及名称
FILE*infile;//文件指针
infile=fopen（indata,"r"）;//打开文本文件
if（!
infile）{
printf（"数据输入文件没找到!
\n"）;
exit
（1）;
}
H=（HLink）malloc（sizeof（HNode））;
rear=H;
while（!
feof（infile））//判断是否读取到文件结尾
{
p=（HLink）malloc（sizeof（HNode））;
fscanf（infile,"%s%f%d",&p->roomN,&p->Price,&p->Beds）;
p->PriceL=（float）0.8*p->Price;
strcpy（p->State,"空闲"）;
rear->next=p;
rear=p;
}
rear->next=NULL;
fclose（infile）;
}
//将床位数为beds客房入住状态改为state
voidupdateH（HLink&H,intbeds,charstate[]）
{
HLinkp;
p=H->next;
while（p）
{
if（p->Beds==beds）
strcpy（p->State,state）;
p=p->next;
}
}
//输出所有客房的客房名称、标准价格、入住价格、床位数、入住状态；
voidExp（HLinkH）
{
HLinkp;
p=H->next;
if（!
p）
{
printf（"数据为空！
\n"）;
return;
}
printf（"\n*************客房信息输出如下***************\n"）;
printf（"-------------------------------------------------\n"）;
printf（"客房名称标准价格入住价格床位数入住状态\n"）;
printf（"-------------------------------------------------\n"）;
while（p）
{
printf（"%s%8.1f%8.1f%6d%8s\n",p->roomN,p->Price,p->PriceL,p->Beds,p->State）;
p=p->next;
}
printf（"\n"）;
}
//将该链表中未入住的客房入住价格均加价20%
voidAdd（HLink&H）
{
HLinkp;
p=H->next;
while（p）
{
if（!
strcmp（p->State,"空闲"））
p->PriceL=（float）1.2*p->PriceL;
p=p->next;
}
}
//将该链表床位数不超过beds的结点都放在床位数超过beds的结点后面
voidupBed（HLink&H,intbeds）
{
HLinkp=H,q,t;
if（p->next->Beds>beds）
{
p=p->next;
}
while（p->next）
{
if（p->next->Beds>beds）
{
t=p->next;
p->next=p->next->next;
q=H->next;
H->next=t;
H->next->next=q;
}
else
p=p->next;
}
}
//求出入住价格最高的客房函数，返回入住价格最高的客房结点指针，返回前将该结点在链表中删除；
HLinkFirstH（HLink&H）
{
HLinkp,q,r=H;
p=H->next;
q=H->next;
floatpriceMax=0.0;
while（p）
{
if（p->PriceL>priceMax）
{
priceMax=p->PriceL;
//q=q->next;
//r=r->next;
}
p=p->next;
}
while（q->PriceL!
=priceMax）
{
q=q->next;
r=r->next;
}
r->next=q->next;
returnq;
}
//将单链表中倒数第k个结点移到第一个结点位置
voidMoveK1（HLink&H,intk）
{
HLinkp,q,r,f;
p=H->next;
q=H->next;
r=H;
f=r->next;
for（inti=0;i{
p=p->next;
}
while（p）
{
p=p->next;
q=q->next;
r=r->next;
}
r->next=q->next;
H->next=q;
q->next=f;
}
//将单链表的正中间位置结点之后的全部结点倒置的功能
voidReverseN2（HLink&H）
{
HLinkp=H,q=H,h;
while（q）
{
if（p->next）
p=p->next->next;
else
{
p=p->next;
break;
}
q=q->next;
}
p=q->next;q->next=NULL;
while（p）
{
h=p->next;
p->next=q->next;
q->next=p;
p=h;
}
}
3.1.1运行结果截图
3.2实验二串模式匹配算法（串）
3.2.1程序流程图
3.2.1源程序
#include
#include
#include
#include
#defineMAXSTRLEN255
typedefunsignedcharSString[MAXSTRLEN+1];
staticinttem,tem1;
//输入字符串
voidgetString（SStringS）
{
SStrings;
printf（"请输入字符串【测试串：
ebababababcaababababcabadaaaacbabababcabad】:
"）;
scanf（"%s",s）;
inti=0;
while（s[i]!
=0）{i++;S[0]=i;}
for（intj=0;jS[j+1]=s[j];
}
//输出字符串
voidOutput（SStringS,SStringT）
{
for（inti=0;iprintf（"\n序号:
"）;
for（intnum=1;num<=S[0];num++）
printf（"%-4d",num）;
printf（"\n"）;
printf（"\n主串:
"）;
for（intnum1=1;num1<=S[0];num1++）
printf（"%-4c",S[num1]）;
printf（"\n"）;
printf（"\n副串:
"）;
for（intnum2=1;num2<=T[0];num2++）
printf（"%-4c",T[num2]）;
printf（"\n\n"）;
}
//朴素的模式匹配法
voidIndex（SStringS,SStringT,intpos）
{
inti=pos,j=1;
while（i<=S[0]&&j<=T[0]）
{
if（S[i]==T[j]）
{
++i;
++j;
}
else
{
i=i-j+2;
j=1;
}
}
if（i<=S[0]-T[0]）
{
printf（"【匹配点为：
%d】\n",i-T[0]）;
Index（S,T,i）;
}
else
{
if（j>T[0]）
printf（"【匹配点为：
%d】",i-T[0]）;
else
printf（"【匹配点为：
%d】",0）;
}
}
//利用模式串T的next函数求T在主串S中第pos字符之后的位置的KMP算法
voidIndex_KMP_next（SStringS,SStringT,intpos,intnext[]）
{
inti=pos,j=1;
printf（"\n第%-2d趟:
",tem）;
for（intnum=0;numprintf（"%-4c",''）;
while（i<=S[0]&&j<=T[0]）
{
if（j==0||S[i]==T[j]）
{
if（j==0）
{
++i;
++j;
}
else
{
printf（"%-4c",T[j]）;
++i;
++j;
}
}
else
{
printf（"%-4c",T[j]）;
printf（"\n\n第%-2d趟:
",++tem）;
j=next[j];
for（intnum2=0;num2printf（"%-4c",''）;
for（intnum=1;numprintf（"[%c]",T[num]）;
}
}
if（i<=S[0]-T[0]）{
printf（"【此处匹配点为：
%d】\n",i-T[0]）;
tem++;
Index_KMP_next（S,T,i,next）;}
else{
if（j>T[0]）
printf（"【此处匹配点为：
%d】",i-T[0]）;
else
printf（"【此处匹配点为：
%d】",0）;
}
}
//利用模式串T的next函数修正值求T在主串S中第pos字符之后的位置的高效KMP算法
voidIndex_K
升级会员 