数据结构实验指导书文档格式.docx
《数据结构实验指导书文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构实验指导书文档格式.docx（34页珍藏版）》请在冰豆网上搜索。
inti=0;
while（i<
len&
&
L->
data[i]!
=x）i++;
if（i==L->
len）return-1;
elsereturn（i+1）;
voidinsert（ListL,intpos,elemtypex）
intj;
len+1）printf（"
inserterror\n"
else{
len++;
for（j=L->
j>
=pos;
j--）
data[j]=L->
data[j-1];
data[pos-1]=x;
};
voiddelnode（ListL,intpos）
{intj;
1||pos>
len）printf（"
delerror\n"
for（j=pos;
j<
j++）
data[j-1]=L->
data[j];
len--;
}
voidprint（ListL）
inti;
for（i=1;
i<
i++）
printf（"
%c->
"
L->
data[i-1]）;
%c"
data[L->
len-1]）;
main（）
inti=1,n;
lnodeL;
charch,x;
init（&
L）;
\n\n\n*******************************顺序表演示程序***********\n"
请输入你想建立的顺序表的元素，以？
结束:
ch=getchar（）;
while（ch!
='
?
'
）
{insert（&
L,i,ch）;
i++;
};
你建立的顺序表为:
print（&
\n顺序表的长度为:
%d"
L.len）;
\n输入你想查找的元素：
fflush（stdin）;
scanf（"
&
x）;
你查找的元素为%c序位为%d"
x,locate（&
L,x））;
\n输入你想查找的元素序位:
n）;
\n你查找的元素为：
getnode（&
L,n））;
\n输入你想插入的元素以及序位:
<
用逗号隔开>
%c,%d"
x,&
insert（&
L,n,x）;
\n插入后顺序表为：
\n请输入你想删除的元素序位：
delnode（&
L,n）;
\n删除后的顺序表为：
getch（）;
四、测试结果
运行程序，屏幕显示：
“请输入你想建立的顺序表的元素，以？
”
输入：
54381
5—>
4—>
3—>
8—>
1
顺序表的长度为:
5
输入你想查找的元素：
4
你查找的元素为4序位为2
输入你想查找的元素序位:
你查找的元素为：
8
输入你想插入的元素以及序位:
：
6，3
插入后顺序表为：
6—>
请输入你想删除的元素序位：
删除后的顺序表为：
一、实验目的：
1、掌握队列和栈的顺序存储结构和链式结构，以便在实际背景下灵活运用。
2、掌握栈和队列的特点，即先进后出与先进先出的原则。
二、实验内容：
停车场管理
[问题描述]
设有一个可以停放N辆汽车的狭长停车场，它只有一个大门利用供车辆进出，车辆按到达停车场时间早晚依次可以从停车场最里面向大门处停放（最先到达的第一辆放在停车场最里面）。
然后停车场已放满N辆车，则后来的车辆只能停在车场大门外的便道上等待，一旦停车场有车开走，在它之后进入停车场的车必须先退出停车场为它让路，待其开出停车场后，这些车辆再依原来的次序进场。
每辆车在离开停车场时，都应依据它在停车场内停留的时间长短交费。
如果停留在便道上的未能进停车场就离去，允许它走，不收停车费，而且仍然保持在便道上的等待的车辆的次序。
编制一程序模拟停车场的管理。
[实现要求]
要求程序输出每辆车到达后的停车位置（停车场或便道上），以及某辆车离开停车场时应交的费用和它在停车场内停留时间；
[实现提示]
汽车的模拟输入信息格式可以是：
（到达/离去，汽车牌照号码，到达/离去的时刻）。
例如，（A，1，5）表示1号牌照车在5这个时刻到达，而（D，5，20）表示5号车在20这个时刻离去，整个程序可以在输入信息为（E，0，0）时结束。
本题可用栈和队列来实现。
[程序实现]
（1）设计思想
根据题目要求，停车场只有一个大门，因此可用一个栈来模拟；
而当栈满后，继续来的车辆只能停在便道上，根据便道停车的特点，可知这可以用一个队列来模拟，安排队的车辆先离开便道，进入停车场。
由于在停车场中间的车辆可以提出离开停车场，而且要求在离开车辆到停车场大门之间的车辆都必须先离开停车场，让此车离去，然后再让这些车辆依原来的次序进入停车场，因此在一个栈和一个队列的基础上，还需要有一个地方保存为了让路离开停车场的车辆，很显然这也应该用一个栈来模拟。
因此本题中用到两个栈和一个队列。
对于停车场和车辆规避所，有车辆进入和车辆离去两个动作，这就是栈的进栈和出栈操作，只是还允许排在中间的车辆先离开停车场，因此在栈中需要进行查找。
而对于便道，也有入队列和出队列的操作，同样允许排在中间的车辆先离去队列。
这样基本动作只需利用栈和队列的基本操作就可实现。
三、详细设计：
#defineN5/*定义停车场长度*/
#defineM10
typedefstruct/*定义栈元素的类型*/
{intnum;
intarrtime;
}elemtype;
typedefstruct/*定义栈*/
{elemtypestack[N];
inttop;
}stack;
typedefstructnode/*定义队列节点类型*/
structnode*next;
}queneptr;
typedefstruct/*定义队列*/
{queneptr*front,*rear;
}quene;
voidinitstack（stack*s）/*初始化栈*/
{s->
top=-1;
intpush（stack*s,elemtypex）/*数据元素X进入指针S所指的栈*/
{if（s->
top==N-1）
return（0）;
else{s->
stack[++s->
top]=x;
return
（1）;
}
elemtypepop（stack*s）
{elemtypex;
if（s->
top<
0）
{x.num=0;
x.arrtime=0;
return（x）;
/*如果栈不空，返回栈顶元素*/
else{x=s->
stack[s->
top];
s->
top--;
returnx;
voidinitquene（quene*s）/*初始化队列*/
front=（queneptr*）malloc（sizeof（queneptr））;
/*产生一个新结点，作为头结点*/
rear=s->
front;
front->
next=NULL;
num=0;
/*头结点的NUM保存队列元素的个数*/
voidenquene（quene*s,intnum）/*数据入队列*/
{queneptr*p;
p=（queneptr*）malloc（sizeof（queneptr））;
p->
num=num;
rear->
next=p;
rear=p;
num++;
intdelquene（quene*s）
{queneptr*p;
intn;
if（s->
front==s->
rear）
/*如果队列空*/
else{p=s->
next;
next=p->
if（p->
next==NULL）
n=p->
num;
free（p）;
num--;
return（n）;
voidarrive（stack*s1,quene*p,elemtypex）
{intf;
f=push（s1,x）;
/*新到达的车辆入停车栈*/
if（f==0）
{enquene（p,x.num）;
/*如果停车场满，就进入队列*/
printf（"
the%dcarstopsthe%dseatofthequene\n"
x.num,p->
num）;
elseprintf（"
the%dcarstopsthe%dseatofthestack\n"
x.num,s1->
top+1）;
voidleave（stack*s1,stack*s2,quene*p,elemtypex）/*处理车辆离去函数*/
{intn,f=0;
elemtypey;
queneptr*q;
while（（s1->
top>
-1）&
（!
f））
{y=pop（s1）;
if（y.num!
=x.num）
n=push（s2,y）;
elsef=1;
if（y.num==x.num）/*如果栈顶元素不是要离开的车辆，就将其放入车辆规避所*/
{printf（"
themoneyofthe%dis%dyuan\n"
y.num,（x.arrtime-y.arrtime）*M）;
while（s2->
-1）
{y=pop（s2）;
f=push（s1,y）;
n=delquene（p）;
if（n）/*在停车场中找到要离开的车辆*/
{y.num=n;
y.arrtime=x.arrtime;
the%dcarstopsthe%dseatofthestak\n"
y.num,s1->
else{while（s2->
-1）/*车辆规避所不空，将其全放回停车场*/
f=push（s1,y）;
q=p->
f=0;
while（f==0&
q->
next!
=NULL）
if（q->
next->
num!
=x.num）/*如果便道上有车辆，将第一辆车放入停车场*/
q=q->
else{q->
next=q->
p->
rear=p->
the%dcarleavethequene\n"
x.num）;
f=1;
if（f==0）/*在便道上没有找到要离开的车辆，输出数据错误*/
printf（"
error!
thestackandthequenehavenothe%dcar\n"
voidmain（）/*停车场模拟管理程序*/
{charch;
stack*s1,*s2;
quene*p;
elemtypex;
inti=1;
clrscr（）;
s1=（stack*）malloc（sizeof（stack））;
s2=（stack*）malloc（sizeof（stack））;
p=（quene*）malloc（sizeof（quene））;
initstack（s1）;
initstack（s2）;
/*初始化停车规避所栈*/
initquene（p）;
/*初始化便道队列*/
while（i）
{
whatdoyouwanttodo?
\n"
input---（Add/Del/Exit）:
scanf（"
ch）;
switch（ch）
{case'
a'
:
inputthenumber:
x.num）;
inputthetime:
x.arrtime）;
arrive（s1,p,x）;
/*车辆到达*/
break;
case'
d'
leave（s1,s2,p,x）;
/*车辆离开*/
e'
theend!
i=0;
break;
default:
{printf（"
inputerror!
---pleaseinputagain:
break;
ch=getchar（）;
四、使用说明：
1、按提示输入车进入停车场的情况
2、按提示输入车离开停车场的情况
3、车离开后计算车进入停车场的时间并得出应收费用。
五、测试结果：
运行程序后，屏幕出现
Input----（add/del/exit）
/*此时停车场为空，a是车进入停车场，d是车离开停车场，e是程序结束。
*/
a
inputthenumber：
/*要求输入停车牌号*/
inputthetime：
/*要求输入停车时间*/
2
/*屏幕返回到提示，可以按以上方法输入多个数据*/
whatdoyouwanttodo?
input----（add/del/exit）/*当输入多个数据后，可以设计车离开*/
d
/*要求输入要离开车牌号*/
/*要求输入车离开的时间*/
themoneyofthe1is30yuan/*输出结果，1小时10元计价收费*/
一、实验目的：
1．
熟练掌握栈的结构，以及这种数据结构的特点；
2．
能够在两种存储结构上实现栈的基本运算，特别注意栈满和栈空的判断条件及描述方法；
二、实验内容：
计算表达式的值
【问题描述】
计算用运算符后缀法表示的表达式的值。
后缀表达式也称逆波兰表达式，比中缀表达式计算起来更方便简单些，中缀表达式要计算就存在着括号的匹配问题，所以在计算表达式值时一般都是先转换成后缀表达式，再用后缀法计算表达式的值。
如：
表达式（a+b*c）/d-e用后缀法表示应为abc*+d/e-。
只考虑四则算术运算，且假设输入的操作数均为1位十进制数（0—9），并且输入的后缀形式表达式不含语法错误。
【数据描述】
#defineadd43/*运算符加号‘+’的ASCII码*/
#definesubs45/*运算符减号‘-’的ASCII码*/
#definemult42/*运算符乘号‘*’的ASCII码*/
#definediv47/*运算符除号‘/’的ASCII码*/
#defineMAXSIZE100
typedefstruct{
{intstkdata[MAXSIZE];
//用数组来表示栈空间，定义长度为MAXSIZE的栈
//栈顶指针
}STKzone;
typedefSTKzone*STK;
typedefenum{true=1,false=0}bool;
typedefenum{ok,error}status;
【算法描述】
用流程图表示见图3-4。
【C源程序】
#include<
stdio.h>
#defineadd43/*运算符加号‘+’的ASCII码*/
#definesubs45/*运算符减号‘-’的ASCII码*/
#definemult42/*运算符乘号‘*’的ASCII码*/
#definediv47/*运算符除号‘/’的ASCII码*/
typedefstruct
/*用数组来表示栈空间，定义长度为MAXSIZE的堆栈*/
/*栈顶*/
STKzoneexpSTKzone;
STKexpSTK;
STKinitSTK（STKzone*stack_zone）{
/*执行栈初始化，建栈指针*/
STKp;
p=stack_zone;
top=0;
statuspush（int*term,STKpstk）{
/*将一结构型数据送入栈中*/
if（pstk->
top==MAXSIZE）
returnerror;
/*栈满，进栈失败*/
pstk->
stkdata[pstk->
top]=*term;
（pstk->
top）++;
/*栈顶指针移动*/
returnok;
}/*push*/
boolemptySTK（STKpstk）{
/*判断栈是否为空栈*/
return（pstk->
top==0）;
statuspop（int*pdata,STKpstk）{
/*从栈中取出一结构型数据*/
if（emptySTK（pstk））
top）--;
/*退栈*/
*pdata=pstk->
returnok;
voidsynerror（）
{printf（"
\n表达式语法错！
exit（）;
inteval（chartag,inta1,inta2）
{switch（tag）
{caseadd:
return（a1+a2）;
casesubs:
return（a1-a2）;
casemult:
return（a1*a2）;
casediv:
return（a1/a2）;
{charc;
intopd1,opd2,temp,c1;
expSTK=initSTK（&
expSTKzone）;
\n后置表达式:
"
while（（c=getchar（））!
\n'
{if（c=='
'
）continue;
if（（c>
47）&
（c<
58））/*判断是否是0—9的字符*/
{putchar（c）;
c1=c-48;
/*把输入的字符型数字转换成数字*/
if（push（&
c1,expSTK）==error）/*运算分量进栈*/
{printf（"
\n表达式太长\n"
exit（）;
elseif（（c==add）||（c==subs）||（c==mult）||（c==div））
{putchar（c）;
if（pop（&
opd1,expSTK）==error）/*将运算量1出栈*/
synerror（）;
if（pop（&
opd2,expSTK）==error）/*将运算量2出栈*/
synerror（）;
temp=eval（c,opd2,opd1）;
/*计算得到结果*/
push（&
temp,expSTK）;
/*将运算结果进栈*/
elsesynerror（）;
/*出现非法字符*/
}/*whil
升级会员 