停车场管理.docx
《停车场管理.docx》由会员分享，可在线阅读，更多相关《停车场管理.docx（16页珍藏版）》请在冰豆网上搜索。
停车场管理
实验二停车场管理
一、实验内容：
设停车场是一个可以停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。
汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已经停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车辆必须先退出场为它让路，待该辆车开出大门外，其他车辆再按次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用，试为停车场编制按上述要求进行管理的模拟程序。
以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。
每一组输入数据包括三个数据项：
汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。
对一组输入数据进行操作后的输出信息为：
若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。
栈以顺序结构实现。
队列以链表结构实现。
设n=2，输入数据为：
（‘A’，1，5），（‘A’，2，10），（‘D’，1，5），（‘A’，3，20），（‘A’，4，25），（‘A’，5，30），（‘D’，2，35），（‘D’，4，40），（‘E’，0，0）。
其中：
‘A’表示到达（Arrival），‘D’表示离去（Departure），‘E’表示输入结束（End）。
二、源程序：
#include
#include
#include
#include
#include
#defineClearScreen（）system（"cls"）
//显示字符串szPrompt并等待用户按下任意键
#definePause（szPrompt）printf（"%s",szPrompt）,getch（）
typedefstructcarinformation//车辆信息
{
charszRegistrationMark[64];//车牌号
charszArrivalTime[16];//到达时间
charszEntranceTime[16];//进入停车场时间
charszDepartureTime[16];//离开时间
}TCARINFORMATION,*LPTCARINFORMATION;
typedefstructcarstack
{
LPTCARINFORMATIONlpCarInformation;//车辆信息
intnTop;//栈顶元素下标
intnStackSize;//栈容量
}TCARSTACK,*LPTCARSTACK;
//初始化栈lpCarStack,将其容量设置为nSize
voidInitStack（LPTCARSTACK&lpCarStack,intnSize）
{
lpCarStack=（LPTCARSTACK）malloc（sizeof（TCARSTACK））;
lpCarStack->lpCarInformation=（LPTCARINFORMATION）malloc（
nSize*sizeof（TCARINFORMATION）
）;
lpCarStack->nTop=-1;
lpCarStack->nStackSize=nSize;
}
//车辆信息carinfo入栈lpCarStack
voidPush（LPTCARSTACK&lpCarStack,TCARINFORMATIONcarinfo）
{
lpCarStack->nTop++;
lpCarStack->lpCarInformation[lpCarStack->nTop]=carinfo;
}
//车辆信息从栈lpCarStack中弹出并存入carinfo
voidPop（LPTCARSTACK&lpCarStack,TCARINFORMATION&carinfo）
{
carinfo=lpCarStack->lpCarInformation[lpCarStack->nTop];
lpCarStack->nTop--;
}
//若栈lpCarstack空,返回TRUE;否则,返回FALSE
BOOLIsStackEmpty（LPTCARSTACKlpCarStack）
{
returnlpCarStack->nTop==-1;
}
//若栈lpStackFull满,返回TRUE;否则,返回FALSE
BOOLIsStackFull（LPTCARSTACKlpCarStack）
{
returnlpCarStack->nTop==（lpCarStack->nStackSize-1）;
}
//销毁栈lpCarStack,将指针lpCarStack置为NULL
voidDestroyStack（LPTCARSTACK&lpCarStack）
{
free（lpCarStack->lpCarInformation）;
free（lpCarStack）;
lpCarStack=NULL;
}
typedefstructcarnode//链队结点信息
{
TCARINFORMATIONcarinfo;//车辆信息
structcarnode*lpNext;//指向下一个元素的指针
}TCARNODE,*LPTCARNODE;
typedefstructcarqueue//链队
{
LPTCARNODElpHead;//头结点
LPTCARNODElpRear;//指向当前队尾的指针
intnEffectiveSize;//当前队中元素个数
}TCARQUEUE,*LPTCARQUEUE;
//初始化链队lpCarQueue
voidInitQueue（LPTCARQUEUE&lpCarQueue）
{
lpCarQueue=（LPTCARQUEUE）malloc（sizeof（TCARQUEUE））;
lpCarQueue->lpHead=（LPTCARNODE）malloc（sizeof（TCARNODE））;
lpCarQueue->lpHead->lpNext=NULL;
lpCarQueue->lpRear=lpCarQueue->lpHead;
lpCarQueue->nEffectiveSize=0;
}
//车辆信息carinfo入队lpCarQueue
voidEnQueue（LPTCARQUEUE&lpCarQueue,TCARINFORMATIONcarinfo）
{
LPTCARNODElpCarNode=（LPTCARNODE）malloc（sizeof（carnode））;
lpCarNode->carinfo=carinfo;
lpCarNode->lpNext=NULL;
lpCarQueue->lpRear->lpNext=lpCarNode;
lpCarQueue->lpRear=lpCarQueue->lpRear->lpNext;
lpCarQueue->nEffectiveSize++;
}
//队头元素从链队lpCarQueue中出队并存入carinfo
voidDeQueue（LPTCARQUEUE&lpCarQueue,TCARINFORMATION&carinfo）
{
LPTCARNODElpTemp=lpCarQueue->lpHead->lpNext;
carinfo=lpTemp->carinfo;
lpCarQueue->lpHead->lpNext=lpTemp->lpNext;
free（lpTemp）;
lpCarQueue->nEffectiveSize--;
}
//若链队lpCarQueue为空,返回TRUE;否则,返回FALSE
BOOLIsQueueEmpty（LPTCARQUEUElpCarQueue）
{
returnlpCarQueue->nEffectiveSize==0;
}
//销毁链队lpCarQueue
voidDestroyQueue（LPTCARQUEUE&lpCarQueue）
{
LPTCARNODElpNextCarNode=NULL;
for（LPTCARNODElpCarNode=lpCarQueue->lpHead;lpCarNode!
=NULL;lpCarNode=lpNextCarNode）
{
lpNextCarNode=lpCarNode->lpNext;
free（lpCarNode）;
}
free（lpCarQueue）;
lpCarQueue=NULL;
}
//将字符串时间格式转换为数字（分钟）格式,例如12:
36将被转换为756（12*60+36）
intConvertTimeFormat（char*lpTime）
{
intnHour=0;
intnMinute=0;
sscanf（lpTime,"%d:
%d",&nHour,&nMinute）;
returnnHour*60+nMinute;
}
//根据在停车场内的停留时间nContinuanceMinutes（分钟）计算费用
doubleCalculateExpense（intnContinuanceMinutes）
{
returnnContinuanceMinutes*（5.0/60）;
}
intmain（void）
{
intnParkCapability=0;//停车场容量
putchar（'\n'）;
printf（"请输入停车场容量:
"）;
scanf（"%d",&nParkCapability）;
LPTCARSTACKlpCarStack=NULL;//停车场,用栈模拟
InitStack（lpCarStack,nParkCapability）;
LPTCARQUEUElpCarQueue=NULL;//便道,用链队模拟
InitQueue（lpCarQueue）;
charcCommandType=NULL;//命令类型
charszUserInput[128];//用户输入
do
{
ClearScreen（）;
putchar（'\n'）;
puts（"--------------------"）;
puts（"[命令类型]"）;
puts（"A-车辆到达"）;
puts（"D-车辆离开"）;
puts（"E-停止输入"）;
puts（"O-显示当前停车场和便道使用情况"）;
putchar（'\n'）;
puts（"例:
"）;
puts（"A,冀A1234,14:
26"）;
puts（"D,冀A1234,16:
51"）;
puts（"E"）;
puts（"O"）;
putchar（'\n'）;
printf（"请输入命令:
"）;
scanf（"%s",szUserInput）;
puts（"--------------------"）;
charszCarInformation[128];
sscanf（szUserInput,//将命令类型与车辆信息分开存放
"%c,%s",
&cCommandType,//用户输入的前半部分,即命令类型
szCarInformation//用户输入的后半部分,即车辆信息
）;
char*lpCommaLocation=NULL;//车辆信息字符串中的逗号位置
for（lpCommaLocation=szCarInformation;*lpCommaLocation!
='\0';lpCommaLocation++）
{
if（*lpCommaLocation==','）
{
break;
}
}
*lpCommaLocation='\0';
TCARINFORMATIONcarinfo;//存储本次用户输入的车辆信息
strcpy（carinfo.szRegistrationMark,szCarInformation）;
if（cCommandType=='A'）
{
strcpy（carinfo.szArrivalTime,lpCommaLocation+1）;
if（FALSE==IsStackFull（lpCarStack））
{
strcpy（carinfo.szEntranceTime,carinfo.szArrivalTime）;
Push（lpCarStack,carinfo）;
printf（"已进入停车场第%d个车位\n",
lpCarStack->nTop+1
）;
printf（"车牌号:
\t\t%s\n",carinfo.szRegistrationMark）;
printf（"进入时间:
\t%s\n",carinfo.szEntranceTime）;
puts（"是否收费:
\t是"）;
}
else
{
EnQueue（lpCarQueue,carinfo）;
printf（"停车场已满,已停放在便道的第%d个车位\n",
lpCarQueue->nEffectiveSize
）;
printf（"车牌号:
\t\t%s\n",carinfo.szRegistrationMark）;
printf（"停放时间:
\t%s\n",carinfo.szArrivalTime）;
puts（"是否收费:
\t否"）;
}
}
elseif（cCommandType=='D'）
{
strcpy（carinfo.szDepartureTime,lpCommaLocation+1）;
LPTCARSTACKlpTempCarStack=NULL;
InitStack（lpTempCarStack,nParkCapability）;
TCARINFORMATIONcarinfoOut;
BOOLbIsCarFound=FALSE;
while（FALSE==IsStackEmpty（lpCarStack））
{
Pop（lpCarStack,carinfoOut）;
if（0!
=strcmp（carinfoOut.szRegistrationMark,carinfo.szRegistrationMark））
{
Push（lpTempCarStack,carinfoOut）;
}
else
{
bIsCarFound=TRUE;
break;
}
}
while（FALSE==IsStackEmpty（lpTempCarStack））
{
TCARINFORMATIONtempcarinfo;
Pop（lpTempCarStack,tempcarinfo）;
Push（lpCarStack,tempcarinfo）;
}
if（FALSE==bIsCarFound）
{
printf（"车牌号为%s的车未进入停车场.\n",carinfo.szRegistrationMark）;
Pause（"--------------------\n按任意键输入下一条信息...\n"）;
continue;
}
strcpy（carinfoOut.szDepartureTime,carinfo.szDepartureTime）;
intnEntranceTime=ConvertTimeFormat（carinfoOut.szEntranceTime）;
intnDepartureTime=ConvertTimeFormat（carinfoOut.szDepartureTime）;
intnContinuanceMinutes=nDepartureTime-nEntranceTime;
printf（"计费时段:
\t%s-%s（共%d分钟）\n",
carinfoOut.szEntranceTime,
carinfoOut.szDepartureTime,
nContinuanceMinutes
）;
doublerExpense=CalculateExpense（nContinuanceMinutes）;
printf（"应交纳的费用:
\t%.1lf元\n",rExpense）;
if（FALSE==IsQueueEmpty（lpCarQueue））
{
TCARINFORMATIONtempcarinfo;
DeQueue（lpCarQueue,tempcarinfo）;
strcpy（tempcarinfo.szEntranceTime,carinfoOut.szDepartureTime）;
Push（lpCarStack,tempcarinfo）;
puts（"--------------------"）;
printf（"停放在便道的第1个车位,车牌号为%s的车已进入停车场\n",
tempcarinfo.szRegistrationMark
）;
}
}
elseif（cCommandType=='E'）
{
puts（"********************"）;
puts（"张学制作\n"）;
puts（"********************"）;
break;
}
elseif（cCommandType=='O'）
{
ClearScreen（）;
putchar（'\n'）;
puts（"[停车场使用情况]\n"）;
puts（"[车位]\t[车牌号]\t[到达时间]\t[进入（开始计费）时间]\n"）;
for（inti=0;i<=lpCarStack->nTop;i++）
{
printf（"%d\t%s\t\t%s\t\t%s\n",
i+1,
lpCarStack->lpCarInformation[i].szRegistrationMark,
lpCarStack->lpCarInformation[i].szArrivalTime,
lpCarStack->lpCarInformation[i].szEntranceTime
）;
}
putchar（'\n'）;
putchar（'\n'）;
putchar（'\n'）;
puts（"[便道使用情况]\n"）;
puts（"[车位]\t[车牌号]\t[到达时间]\t[进入（开始计费）时间]\n"）;
intnNum=0;
for（LPTCARNODElpCarNode=lpCarQueue->lpHead->lpNext;
lpCarNode!
=NULL;lpCarNode=lpCarNode->lpNext）
{
nNum++;
printf（"%d\t%s\t\t%s\t\t%s\n",
nNum,
lpCarNode->carinfo.szRegistrationMark,
lpCarNode->carinfo.szArrivalTime,
lpCarNode->carinfo.szEntranceTime
）;
}
putchar（'\n'）;
}
else
{
puts（"输入信息有误.第一个字符只能为'A'或'D'或'E'或'O'（区分大小写）."）;
}
Pause（"--------------------\n按任意键输入下一条信息.\n"）;
}while（TRUE）;
DestroyStack（lpCarStack）;
DestroyQueue（lpCarQueue）;
Pause（"\n按任意键退出程序...\n"）;
return0;
}
三、调试过程：
1、参考资料《c语言参考手册》、《c、c++程序设计》、《数据结构（c语言版）》。
2、最初写的程序对数据结构的领会不够深刻，也不符合c++的编程思想。
于是彻底从新编写。
停车场管理分进停车场和出停车场，进停车场又分进栈和进队列，出停车场分为“找”、“出”、“进”三步，“出”中又有让与不让车的问题。
最基础的是建栈，建队列，因为我认为链式的栈和队列简单，所以我用顺序栈和顺序队列。
根据以上思想编出新程序（即：
最后完成程序）
3、我在编程中找到了一个偷懒的办法：
复杂的变量调用中，如果“.”不对，那么“->”就对。
我用这种方法，成功的调用了复杂的变量，并找到规律。
4、程序调试通过，但运行时发现在最后找车辆位置时，第5号车在等候区，这是不可能的，通过对临界情况的调整，第5好车在停车场4号，这也不对，通过对程序检查，发现计数器没有在新一轮计数中置零，改正后正确。
5、本程序缺陷：
只能进行100辆以内的统计，在搜索车辆位置中未考虑有效的数据位置即两个指针间的有效数据，当多次重复时，队列内的车辆位置会出错。
6、请老师告诉我在编程中的潜在问题，以及我的原始程序的错误。
四、运行结果：
升级会员 