数据结构课程设计c++版停车场管理系统.docx
《数据结构课程设计c++版停车场管理系统.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计c++版停车场管理系统.docx（20页珍藏版）》请在冰豆网上搜索。
数据结构课程设计c++版停车场管理系统
～
《数据结构》
课程设计
班级网络营销
指导老师吕向阳
学号1040412123
姓名魏华
二012年1月7日
一．课程设计题目
某停车场内只有一个可停放n辆汽车的狭长通道,且只有一个大门可供汽车进出.汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆汽车停放在最北端），若停车场内已经停满n辆车，则后来的汽车只能在门外的便道即候车场上等候，一旦有车开走，则排在便道上的第一辆车即可开入。
当停车场内某辆车要离开时.在它之后进入的车辆必须先退出车场为它让路，该车辆开出大门外，其它车辆再按原次序进入停车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。
试为该停车场编制按上述要求进行管理的模拟程序.
二．流程及图示
停车显示信息
离开收费
系统
查询显示信息
退出
a1
a2
a3
………
an
停车场（栈1）
栈2
通道（队列）
三、程序运行及截图
1。
开始界面
首先是登陆界面，只要用户名跟密码一样就可以登陆，输入正确后，有一个延迟程序，让使用者感觉更真实
如果输入错误了，就是直接退出了
2.主界面登录成功后，则是如下的功能界面：
3。
停车场管理系统你可以选择停车,离开，或者查看，当操作完了，可以直接选择退出.当你输入1后，会提示你输入停车的车号：
在这里输入你想要停车的车号，然后会提示你停车的时间：
输入停车时间后，则会显示你刚停车的详细的信息：
4.离开输入2，则会提示你要离开的车号：
然后输入离开的车号后,会提示你输入该车离开的时间，输入离开的时间,则会出现如下界面:
5停车场管理系统系统则会把你刚离开的车俩的详细信息给你打印出来：
拉开的车号,所用时间以及应收的费用。
这个时间管理员，可以对照表收费了。
6。
查看当你要查看停车场所停车的信息时,你可以选择3。
同样，选择3确定后会提示你要查看的车号，然后则会把信息打印在界面上：
系统会告诉你这俩停在停车场里面的那个位置上。
7.退出当你一切操作完了后，就可以选择退出了，输入4停车场管理系统随便按个键就退出该系统了.
四、程序代码
＃include〈iostream〉
＃include＃include
＃include〈fstream〉
#include
#includeh〉
#includeusingnamespacestd;
＃defineMax_Size2//停车的最大容量
＃defineHourFare2//每小时的停车费用
intCountForStack=0;//栈里现有的车数
intCountForQueue=0;//排队等候的车数
typedefstruct
｛
charCondition;//到达或者离开的状态
intArrivetime;//到达时间,默认为—1,表示没有到达
intLeavetime;//离开时间，默认为—1，表示没有离开
intLicense;//车牌号
}
CarNode;//保存每辆车的信息
typedefstruct//栈的定义
{
CarNode＊base;//栈底指针
CarNode*top；//栈顶指针
intStacksize;//栈的最大容量
}
CarStack；
typedefstructQNode
{
charCondition；//到达或者离开的状态
intArrivetime；//到达时间，默认为—1,表示没有到达
intLeavetime；//离开时间，默认为-1，表示没有离开
intLicense；//车牌号
QNode＊next；
｝
QNode；
typedefstruct//队列的定义
｛
QNode*front;//对头指针
QNode*rear；//队尾指针
｝
Queue;
boolInitStack（CarStack＆S1）//初始化栈S1
{
S1.base=（CarNode*）malloc（Max_Size*sizeof（CarNode））；
if（！
S1.base）
{
cout<<”栈S1内存分配失败"〈〈endl；
returnfalse;
｝
S1。
top=S1.base;
S1.Stacksize=Max_Size;
returntrue；
}
boolInitQueue（Queue＆Q）
｛
Q.front=（QNode*）malloc（sizeof（QNode））;
if（！
Q.front）
｛
cout<〈"队列Q内存分配失败!
”〈〈endl；
returnfalse；
｝
Q.rear=Q。
front；
Q.front—>next=NULL；
returntrue；
}
boolEnQueue（Queue＆Q，QNode&e）//插入元素e为Q的新的队尾元素
｛
QNode*p=（QNode＊）malloc（sizeof（QNode））；
if（！
p）
｛
cout<〈”p内存分配失败"<〈endl；
returnfalse;
}
p—>Arrivetime=e。
Arrivetime；
p—>Leavetime=e。
Leavetime；
p—〉Condition=e。
Condition；
p->License=e。
License;//将e赋给P
p—>next=NULL；
Q.rear—〉next=p；
Q。
rear=p；
returntrue；
｝
boolDeQueue（Queue＆Q，QNode＆t）//出队列函数
｛
if（Q。
front==Q。
rear）
｛
cout<<”队列为空！
”<〈endl；
returnfalse；
｝
QNode＊p=Q。
front->next；
t。
Arrivetime=p—>Arrivetime；
t。
Condition=p-〉Condition;
t。
Leavetime=p—〉Leavetime;
t。
License=p-〉License;
Q。
front—〉next=p-〉next；
if（Q。
rear==p）
｛
Q.rear=Q。
front;
｝
free（p）；
returntrue;
｝
voidInitCarNode（CarNode＆C，charcondition,intarrivetime,intleavetime，intlicense）
｛
C.Arrivetime=arrivetime;
C.Condition=condition;
C。
Leavetime=leavetime；
C.License=license;
｝
boolPush（CarStack&S1，CarNode＆car）//插入新的元素car为的栈顶元素
｛
if（S1.top—S1.base〉=S1。
Stacksize）
｛
cout<<"此栈已满，不能压入新的信息"<returnfalse；
}
（*S1。
top）。
Arrivetime=car.Arrivetime;
（＊S1.top）。
Condition=car.Condition；
（＊S1.top）.Leavetime=car。
Leavetime；
（＊S1。
top）。
License=car。
License;
++S1.top；//栈顶指针上移
returntrue；
｝
boolPop（CarStack＆S1，CarNode＆t）//出栈操作
｛
if（S1。
top==S1。
base）
{
cout<<”栈S1为空，不能执行出栈操作”〈〈endl；
returnfalse；
｝
-—S1。
top；//栈顶指针下移
t。
Arrivetime=（＊S1。
top）.Arrivetime；
t.Condition=（*S1.top）.Condition；
t。
Leavetime=（＊S1.top）。
Leavetime；
t。
License=（＊S1。
top）。
License;
returntrue;
｝
boolIsStackFull（CarStack＆S1）//判断S1栈是否已满
{
if（S1.top—S1。
base>=S1.Stacksize）
returntrue；
else
returnfalse;
｝
boolIsStackEmpty（CarStack＆S1）//判断S1栈是否已空
｛
if（S1。
top==S1.base）
returntrue;
else
returnfalse；
｝
boolIsQueueEmpty（Queue&Q）//判断队列是否为空
{
if（Q。
front==Q。
rear）
returntrue;
else
returnfalse;
｝
boolSearchInStack（CarStack&S1，inta）//a表示要查找的车牌号,如果在停车场里面,就返回true
{
booltag=false；
if（!
IsStackEmpty（S1））//如果栈S1非空
｛
CarNode*p=S1.top—1；
while（p！
=S1。
base）
｛
if（（＊p）。
License==a）
tag=true；
-—p；
｝
if（（*p）.License==a）
tag=true;
}
returntag；
}
boolSearchInQueue（Queue＆Q,inta）//a表示要查找的车牌号，如果在通道里面,就返回true
｛
booltag=false；
if（！
IsQueueEmpty（Q））//如果队列非空
{
QNode＊p=Q。
front—〉next;
while（p！
=Q。
rear）
{
if（（＊p）。
License==a）
tag=true;
p=p—〉next；
}//退出此while循环时p指向最后一个元素
if（（＊p）.License==a）
tag=true;
｝
returntag；
｝
voidInCar（CarStack＆S1，Queue＆Q，inta1,inta2）//表示进入车辆，a1表示到达时间，a2表示车牌号码
{
if（SearchInStack（S1，a2））
｛
cout〈〈"车号"〈return；
｝
if（SearchInQueue（Q，a2））
{
cout〈〈”车号”〈〈a2〈〈”已经存在于通道内,输入有误"<〈endl；
return；
}
if（IsStackFull（S1））//如果堆栈已满，说明停车场已满，需要停车在通道里面
｛
QNodeqnode;
qnode。
Arrivetime=—1；//在通道里面不收费,所以不计时
qnode。
Condition=’A’;
qnode.Leavetime=-1；//定义为—1,说明还没有开始离开
qnode.License=a2;
EnQueue（Q，qnode）；//停在通道上
++CountForQueue;
cout〈〈”车号：
"〈｝
else
{
CarNodecarnode;
carnode.Arrivetime=a1；
carnode.Condition=’A’;
carnode。
Leavetime=—1;
carnode.License=a2;
Push（S1,carnode）；
++CountForStack;
cout〈〈”车号:
”〈〈carnode。
License〈<”，到达时间:
"〈Arrivetime<〈”点，停在停车场的第”〈｝
｝
voidSreach（CarStack＆S1，Queue＆Q,inta）
｛
if（SearchInStack（S1,a））
｛
cout<〈”车号：
”〈return；
｝
if（SearchInQueue（Q，a））
｛
cout<〈”停车场已满,车号”〈〈a<<”存在于通道里面的第”<return;
｝
else
｛
cout〈〈"对不起！
你查找的车号不在停车场里面"〈〈endl；
return;
}
｝
voidOutCar（CarStack&S1，Queue&Q，inta1，inta2）//出车函数,a1表示离开时间，a2表示车牌号码
｛
if（SearchInQueue（Q，a2））
｛
cout〈〈"车号”<〈a2〈〈”存在于通道里面,还没有进入停车场,不能离开”〈〈endl;
return；
｝
if（！
SearchInStack（S1,a2））
｛
cout〈〈"车号”<〈a2〈<”该车不在停车场内”<〈endl;
return；
｝
CarStacktempstack；
InitStack（tempstack）；//新建一个栈，存放让路的汽车
booltag1=false；//标志这个停车场出车以前是否已满，默认为没有满
tag1=IsStackFull（S1）;
booltag2=true；//标志通道是否有汽车在等待,默认为通道为空
tag2=IsQueueEmpty（Q）;CarNodetemp；//用来保存暂时取出的汽车
booltag3=false；
while
（1）
｛
Pop（S1，temp）;
if（temp。
License==a2）
｛
if（a1〈temp.Arrivetime）
{
cout〈〈”离开失败！
”<tag3=true;
Push（tempstack，temp）；
｝
else
｛
cout〈<”车号:
"<〈a2<〈”现在离开停车场,所用时间为:
"〈〈a1-temp。
Arrivetime〈<”小时，应收RMB为:
"<〈（a1—temp.Arrivetime）＊HourFare<〈"元"<〈endl；
}
break；
｝
else
Push（tempstack,temp）；//进入暂存栈｝则把前面倒出的车再次放
while（！
IsStackEmpty（tempstack））//如果临时栈不空，入停车场
｛
Pop（tempstack，temp）；
Push（S1,temp）；
}
QNodetempqnode；//用来暂时保存从通道出来的汽车
if（tag1==true＆＆tag2==false&&tag3==false）//如果出车前停车场已满，并且通道不为空，并且离开没有失败
{
DeQueue（Q，tempqnode）；
——CountForQueue;
temp。
Arrivetime=a1；
temp。
Condition=tempqnode.Condition;
temp。
Leavetime=tempqnode。
Leavetime；
temp。
License=tempqnode.License；
Push（S1，temp）；
｝
if（tag3==false）//如果停车通道是空的,停车场没有满,并且离开成功
｛
—-CountForStack；
｝
｝
｝
voidshowmenu（CarStack&S1，Queue&Q）
｛
cout<〈”***＊*＊＊＊＊*＊＊＊*＊＊＊＊*＊＊*＊＊＊*＊*＊*选择菜单＊＊**＊*＊*＊**＊***＊*＊＊＊＊＊**＊*＊*＊＊＊”〈〈endl；
cout〈〈”1：
停车”<cout<〈”2:
离开停车场”<〈endl；
cout<<"3:
查看车辆信息”〈〈endl；
cout〈<"4:
退出系统"〈cout〈〈"****＊＊＊*＊**＊*＊*＊*＊＊**＊＊＊****＊请按键选择**＊*＊***＊＊*＊＊＊＊****＊＊＊＊*＊＊***＊”<inttag；
cin〉>tag;
while（tag!
=1＆＆tag！
=2＆＆tag！
=3＆&tag！
=4）
cin〉〉tag；
inta1；
unsignedinta2;
switch（tag）
{
case1:
cout〈〈"请输入到达的车号：
”〈cin>>a1；
cout<〈"请输入到达的时间：
"〈cin〉〉a2；
InCar（S1，Q，a2,a1）;
Sreach（S1,Q，a1）;
break；
case2：
cout<〈"请输入离开的车号:
”〈cout〈<”请输入离开的时间：
”<〈endl;cin〉>a2；
OutCar（S1，Q，a2，a1）；
break；
case3：
cout〈<”请输入你要查看的车号：
”〈〈endl；
cin>>a1;
Sreach（S1,Q，a1）;
break;
case4:
return;
break；
}
showmenu（S1，Q）；
｝
voidloging（CarStack&S1，Queue&Q）
｛
charAdministrator[15],password[15］;
inta；
printf（"\t＊＊***＊*＊*＊＊＊****＊＊*＊*＊＊＊＊**＊＊＊＊＊＊＊**＊＊*＊＊＊＊*＊＊＊＊＊＊＊＊＊\n"）；
printf（"\t＊＊＊*＊＊*＊＊*＊＊*＊＊＊**＊＊＊*＊＊＊***＊＊**＊**＊＊****＊＊＊＊**＊＊＊＊＊*\n”）；
printf（"\t＊**＊\n"）;
printf（"\t**欢迎使用停车场管理系统＊＊\n”）;
printf（"\t＊**＊\n"）;
printf（"\t**＊＊\n"）；
printf（”\t*＊***＊*＊*＊*＊***＊＊*＊＊**＊＊**＊＊＊＊*＊＊＊****＊*＊＊*＊＊＊*＊＊***＊\n”）；
printf（"\t*＊*＊＊*＊＊＊*＊＊＊＊＊*＊**＊＊＊＊＊＊＊＊＊＊*＊＊**＊＊＊*＊*＊＊*＊＊＊＊＊＊*＊＊＊\n”）；
printf（”\n\t（提示：
账号跟密码一样就行）”）;
printf（"\n\n\n\n\t请输入管理员帐号：
”）；
fflush（stdin）;
gets（Administrator）；
printf（”\t\t\t\t\t\t\t\t\t\t\t请输入密码:
”）；
fflush（stdin）;
gets（password）；//比较用户名和密码
if（strcmp（Administrator，Administrator）==0＆&strcmp（password，Administrator）==0）
｛
printf（”\n\n\t\t\t您已成功登陆，请稍侯！
\n\n\t\t\t”）;//延迟
for（a=0；a<20；a++）
{
printf（”>"）；
Sleep（150）;
｝
//进入页面时清屏
system（"cls”）;
showmenu（S1,Q）;
｝
else
printf（”\n\n\t\t\t您输入的帐号或者密码错误!
\n\n\t\t\t”）;
return；
}
voidmain（）
{
CarStackcarstack;
InitStack（carstack）；//建立并且初始化用于停车场的堆栈
QueuecarQueue;
InitQueue（carQueue）;//建立并且初始化用于通道的队列
loging（carstack,carQueue）；
}
五、心的体会
在生活与工作中许多领域都用到数据结构,但关键是如何将问题模型转换,变换成我们熟知的知识应用，即抽象具体化。
首先是要把所学的知识重新好好巩固下，其次，每次课程设计总会有些东西不懂的，这时我们就要上网去查资料，这样会让我们养成一个好的自主学习的习惯。
这次的课程设计，我开始是分析了这个系统需要做些什么,然后分析要用到哪些代码,哪些结构，哪些算法开实现这些功能。
它让我明白了栈和队列实际会用在哪些方面，同时我有些不懂的，我会看书，或是在网上找，慢慢的也增加了自己的知识量。
这次的停车场系统做的很简单，和真正的停车场系统来比，根本就不算什么了。
真正的停车场是不会那么退出停车场的,每次离开都要人家
升级会员 