数据结构停车场管理完整版实习报告.docx

数据结构停车场管理完整版实习报告.docx

《数据结构停车场管理完整版实习报告.docx》由会员分享，可在线阅读，更多相关《数据结构停车场管理完整版实习报告.docx（16页珍藏版）》请在冰豆网上搜索。

数据结构停车场管理完整版实习报告

实习报告

题目：

停车场管理

一．需求分析

1．用栈来表示停车场，用队列来表示停车道。

2．用户需输入车辆的必要信息，如车辆的到达或离开，汽车牌号以及到达或离去的时刻。

停车场的容量及单位时间的停车费由编程序者自行设置，结构需输出车辆停车所需缴纳的费用。

3．本程序要求对车辆的动态能够输出具体的信息内容，包括停车或离开的时间，位置，及所需缴纳的停车费。

4．测试数据为：

N=2，输入数据为：

（’A’,1,5）,（‘A’,2.,10）,（‘D’,1,15）,（‘A’,3,20）,（‘A’,4,25）,（‘A’,5,30）,

（‘D’,2,35）,（‘D’,4,40）,（‘E’,0,0）.其中：

’A’表示到达，’D’表示离去，’E’表示输入结束。

5.程序执行的命令为：

1.创建栈和队列。

2.对车辆的行为进行相应的处理。

3.输出车辆的信息。

二．概要设计

1.设定栈的抽象数据类型定义：

ADTStack{

数据对象：

D={ai|ai属于Elem,i=1,2……,n,n>=0}

数据关系：

R1={|ai-1,ai属于D，i=2,……，n}

基本操作：

initStack（&S）

操作结果：

构造一个空栈S.

pop（&S,&e）

初始条件：

栈S已存在。

操作结果：

删除S的栈顶元素，并以e返回其值。

push（&S,&e）

初始条件：

栈S已存在。

操作结果：

在栈S的栈顶插入新的栈顶元素e。

lengthstack（S）

初始条件：

栈S已存在。

操作结果：

返回S中的元素个数，即栈的长度。

}ADTStack;

2.设定队列的抽象数据类型定义：

ADTQueue{

数据对象：

D={ai|ai属于Elem,i=1,2,……，n,n>=0}

数据关系：

R1={|ai-1,ai属于D，i=2,……,n}

基本操作：

initqueue（&Q）

操作结果：

构造一个空队列Q.

enqueue（&Q,e）

初始条件：

队列Q已存在。

操作结果：

插入元素e为Q的新的队尾元素。

dequeue（&Q,&e）

初始条件：

Q为非空队列。

操作结果：

删除Q的对头元素，并用e返回其值。

Lengthqueue（Q）

初始条件：

队列Q已存在。

操作结果：

返回Q的元素个数，即队列的长度。

}ADTQueue

3.本程序主要包括三个模块

1.主程序模块；

intmain（）

{

初始化；

do{

接受命令；

处理命令；

}while（命令！

=退出）；

}

2.处理车辆到达模块；

3.处理车辆离开模块；

各模块之间的调用关系如下：

处理车辆到达模块主程序模块处理车辆离开模块

三．详细设计

设计程序如下：

#include

#definen2

//将停车场的容量设为2；

#definecost10

//将单位时间的停车费设为10，车道里不收费；

#defineOVERFLOW-2

#defineERROR0

//分配栈的存储空间失败；

usingnamespacestd;

typedefstructElem

{//定义元素数据结构类型

intcarnum;

inttime;

}Elem;

typedefstructQNode

{//队列

structQNode*next;

ElemQelem;

}QNode,*QueuePtr;

typedefstruct

{

QueuePtrfront;//队头指针

QueuePtrrear;//队尾指针

}LinkQueue;

voidinitqueue（LinkQueue&Q）

{//构造一个空队列

Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;

if（!

Q.front）exit（OVERFLOW）;

Q.front->next=Q.rear->next=NULL;

}

voidenqueue（LinkQueue&Q,intcarnum,inttime）

{//入队操作

QueuePtrp=（QueuePtr）malloc（sizeof（QNode））;

p->Qelem.carnum=carnum;

p->Qelem.time=time;

p->next=NULL;

Q.rear->next=p;

Q.rear=p;

}

intlengthqueue（LinkQueueQ）

{

inti=0;

QueuePtrp;

p=Q.front->next;

while（p!

=Q.rear）

{

i++;

p=p->next;

}

i++;

returni;

}

voiddequeue（LinkQueue&Q,Elem&e）

{//从对头离队操作，并返回其值

QueuePtrp=（QueuePtr）malloc（sizeof（QNode））;

if（Q.front==Q.rear）

cout<<"车道中没有车辆!

"<

if（Q.front!

=Q.rear）

{

p=Q.front->next;

e=p->Qelem;

Q.front->next=p->next;

if（Q.rear==p）Q.rear=Q.front;

free（p）;

}

}

typedefstruct

{

Elem*base;

Elem*top;

intstacksize;

}Sqstack;

voidinitStack（Sqstack&S）

{//创建一个空栈

S.base=（Elem*）malloc（n*sizeof（Elem））;

if（!

S.base）exit（OVERFLOW）;

S.top=S.base;

S.stacksize=n;

}

intpush（Sqstack&S,Elem&e）//插入新的元素

{

Elem*temp;

if（S.top-S.base==S.stacksize）

return1;

else

{

temp=S.top;

temp->carnum=e.carnum;

temp->time=e.time;

S.top++;

return0;

}

}

intlengthstack（SqstackS）

{//当前栈的长度

returnS.top-S.base;

}

intpop（Sqstack&S,Elem&e）{

//删除栈顶元素，并返回其值

if（S.top==S.base）returnERROR;

e=*--S.top;

return1;

}

voidcarin（Sqstack&S,LinkQueue&Q,Elemcar）

{

intk=0;//输入数据正确

QueuePtrr;

Elem*temp;

temp=S.base;

while（temp!

=S.top）

/在栈中寻找是否有同一编号的车；

{

if（temp->carnum==car.carnum）

{

cout<<"该车号在停车场中已存在，请重新输入!

"<

k=1;//找到了有同一编号的车

break;

}

temp++;

}

if（k==0&&Q.front!

=Q.rear）

{//在栈中未找到，从队列中查找

r=Q.front->next;//队头

while（r&&r->Qelem.carnum!

=car.carnum）

{r=r->next;}

if（r&&r->Qelem.carnum==car.carnum）{cout<<"该车号在车道中已存在,请重新输入!

"<

}

if（k==0）//说明经检查输入数据正确；

{

if（S.top-S.base!

=S.stacksize）//说明栈未满，

{

S.top->carnum=car.carnum;

S.top->time=car.time;

S.top++;

cout<<"请进入停车场"<

"<

}

else

{

enqueue（Q,car.carnum,car.time）;

cout<<"请便车道"<

"<

}

}

}

voidcarleave（Sqstack&S,LinkQueue&Q,Elemcar）

{

intture=0;//在栈中没有找到与要离开的车

Eleme,em,*temp;

QueuePtrp,r;

temp=S.base;

if（ture==0）

{

while（temp!

=S.top）//先在栈中寻找；

{

if（temp->carnum==car.carnum）

{

inttemp_cost;

temp_cost=（car.time-temp->time）*cost;

ture=1;//在栈中找到

cout<<"您的停车时间为"<time<<"小时，请交纳费用!

"<

break;

}

temp++;

}

if（ture==1）//备用栈

{

Sqstackspear;

initStack（spear）;

while（S.top!

=temp+1）//先在栈中寻找；

{

pop（S,em）;

push（spear,em）;

}

pop（S,*temp）;

if（spear.top!

=spear.base）

{

while（spear.top!

=spear.base）

{

pop（spear,em）;

push（S,em）;

}

}

}

if（ture==1&&Q.front!

=Q.rear）//栈中有车离开，将队列中的车进入栈中

{

dequeue（Q,e）;//离队，并返回数据e

S.top->carnum=e.carnum;

S.top->time=car.time;

S.top++;

cout<

"<

"<

"<<"停车位置为"<

"<

}

}

if（ture==0&&Q.front!

=Q.rear）//栈中没找到要离开的车

{

p=Q.front;

r=Q.front->next;//队头

while（r&&r->Qelem.carnum!

=car.carnum）

{

p=r;

r=r->next;

}

if（r&&r->Qelem.carnum==car.carnum）

ture=2;//在队列中找到要离开的车

if（r&&r->Qelem.carnum==car.carnum）

{

ture=2;

cout<<"便道"<Qelem.carnum<<"号车离开,不收取费用！

"<

p->next=r->next;

free（r）;

}

}//直接从队列离开

if（ture==0）

cout<<"没有该辆车!

"<

}

intmain（）

{

charc;

intj=0,temp_time,i=1;//i==0，判断临时记录时间的temp_time应该去该次的值，还是上次的值。

j==0，表示第一次输入数据，不需要检测数据是否正确

LinkQueueQ;

SqstackS;

Elemcar;

initqueue（Q）;

initStack（S）;

cout<<"请输入车辆信息（到达离开或退出标志ADE，车牌号，当前时间）"<

while（cin>>c>>car.carnum>>car.time）

{

if（j==1）

{

if（S.top==S.base）

cout<<"停车场中没有车!

"<

else

{

if（car.time

='E'）

{

cout<<"您输入的时间有误，请重新输入!

"<

i=0;//temp_time还是记录上次的值

}

else

{

temp_time=car.time;

i=1;

}

}

if（i==1）//正确的数据

{

if（c=='A'）//到达

carin（S,Q,car）;

elseif（c=='D'）

{

if（S.top==S.base）;

else

carleave（S,Q,car）;

}

}

j=1;

}

if（j==0）//第一次输入数据不需要检测

{

if（c=='A'）//到达

carin（S,Q,car）;

elseif（c=='D'）

{

if（S.top==S.base）

cout<<"停车场中没有车!

"<

else

carleave（S,Q,car）;

}

j=1;

temp_time=car.time;

}

if（c=='E'）

{

cout<<"输入结束！

"<

break;

}

}

return0;

}

四．调试分析

1.本次作业是设计停车场的管理系统，就需要判断车牌号，及时间的输入的正确性，

输入的数据有比较严格的要求，必须符合实际。

因此对数据需要多次判断。

2.处理车辆到达模块和处理车辆离开模块其空间复杂度为O（m*n）;

3.本程序循环用的很多，找车，排队，等等。

4.主程序设计的有点乱。

五．测试结果