停车场管理课程设计报告汇总

停车场管理

一、 课程设计题目内容 （1）问题描述：

设停车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等待，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。试为停车场编制按上述要求进行管理的模拟程序。 基本要求：

以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。栈以顺序结构实现，队列以链表结构实现。 测试数据：

设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’表示到达（Arrival）；‘D’表示（Departure）；‘E’表示输入结束（End）。 实现提示：

需另设一个栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车，也用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中每个元素表示一辆汽车，包含两个数据项：汽车的牌照号码和进入停车场的时刻。

二、 本人完成的工作

（1） 定义车辆信息结构体，包括汽车的车牌号码、到达停车场时间、离开停车

场时间；

（2） 定义顺序堆栈的结构体，用于模拟停车场；

（3） 定义链式队列的结构体，用于模拟车场外的停车场； （4） 定义堆栈和队列的初始化函数； （5） 设计汽车进入停车场、离开停车场、离开收费信息和汽车停靠情况查询等

主要函数；

（6） 主函数：设计停车场管理菜单，通过菜单选项，调用相关的函数来实现停

车场汽车到达登记、汽车离开停车场、汽车停靠查询和退出程序的操作，完成模拟汽车停车场的整个过程。

三、 所采用的数据结构

数据结构的定义：

typedef struct car //定义车辆信息的结构体 {

long CarNo; //车牌号 int Atime; //车到达时间 int Dtime; //车离开时间 }CarNode;

typedef struct node //定义模拟停车场的顺序堆栈 {

CarNode stack[Maxsize+1]; //栈底不存放元素，即停车场共有Masize个位置

int top; //栈顶指针 }StackCar; typedef struct qnode //用队列结点定义，构造停车场外的单个等候车辆 {

CarNode data; //数据域 struct qnode *next; //指针域 }QNode;

typedef struct Node //用队列定义，构造停车场外的等候便道 {

QNode *front; //队头指针 QNode *rear; //队尾指针 }LinkQueue;

四、 所设计的函数

1）void StackInitiate(StackCar *s) //堆栈初始化 {

s->top=0; //栈顶置0 }

初始方法：初始化顺序栈，只需令栈顶的下标值置为0即可。 程序框图：

堆栈的初始化（s）

s->top=0

初始化成功！

2）LinkQueue *Init_LinkQueue(void)//链队列的初始化 {

LinkQueue *Q;QNode *p;

p=(QNode *)malloc(sizeof(QNode)) ; /* 开辟头结点 */ p->next=NULL;

Q=(LinkQueue *)malloc(sizeof(LinkQueue));/* 开辟链队的指针结点 */ Q->front=Q->rear=p; return(Q) ; }

初始方法：开辟一个队列的头结点p，其next指针为空，再开辟链队的指针结点Q，用p来初始化链队结点的队头指针和队尾指针。初始化成功后，返回Q 程序框图： 队列的初始化

LinkQueue *Q;QNode *p

p=(QNode *)malloc(sizeof(QNode)) p->next=NULL

*)malloc(sizeof(LinkQueue)) Q=(LinkQueue Q->front=Q->rear=p

return(Q)

初始化成功

3）void Arrival(StackCar *car1,LinkQueue *car2) //车辆进入停车场操作 {

CarNode p; QNode *q;

printf(\"\\n++++++++++++车辆到达登记表+++++++++++\"); printf(\"\\n请输入车牌号(整型，例如：1234):\"); scanf(\"%d\输入车牌号

if(car1->top栈未满，进入停车场 {

car1->top++; //栈顶指针+1

printf(\"\\n【汽车顺利停放在车场的第%d位置】\\n\ while(1) {

printf(\"\\n车辆几点钟到达(%d~23点):\ scanf(\"%d\

if(p.Atime>23 || p.Atimeprintf(\"输入时间有误，请重新输入!\"); else {

n=p.Atime;

printf(\"\\n北京时间%d:00整\\n\ break; } }

car1->stack[car1->top]=p; //将车停入停车场，停放在top位置 }

else //停车场已停满车，即栈已满，则停靠在便道 {

printf(\"\\n停车场已满，请先在便道等候!有车位时进入车场!\\n\"); q=(QNode *)malloc(sizeof(QNode)); q->data=p;

q->next=NULL; //形成新的结点，保存车辆信息 car2->rear->next=q;

car2->rear=q; //新结点入队尾，即车辆进入便道等候 }

printf(\"+++++++++++++++++++++++++++++++++++++\\n\"); }

算法思想：当车进入车场时，登记车的车牌号，如果停车场有空位，将车停放在相应的空位，输出此时车停放的位置，记录到达时间；如果停车场没有空位，便将车开到便道等候。其过程相当于，当顺序栈未满时，进栈；当顺序栈已满时，无法入栈，便进入队列。

程序框图：

Arrival(StackCar *car1,LinkQueue *car2) CarNode p; QNode *q; 提示：输入车牌号 输入：p.CarNo 提示：停车场已 car1->top<满，在便道等候 Maxsize？ N Y q=(QNode *)malloc(sizeof(QNode)) car1->top++ q->data=p 打印车停放的位置 q->next=NUL car2->rear->next=q 输入：p.Atime car2->rear=q car1->stack[car1->top]=p 车在便道等候 车进入停车场 4）void output(CarNode p) //输出车离开停车场离开时间、收费等信息 {

int a,b; while(1) {

printf(\"\\n车辆离开的时间(%d点~24点之间的时间):\

scanf(\"%d\输入车辆离开的小时、分钟 if(p.Dtime>24 || p.Dtimeprintf(\"输入时间不符合，重新输入!\ else

{

n=p.Dtime;

printf(\"\\n北京时间%d:00整\\n\ break; } }

printf(\"\\n**********车辆离开信息表**********\"); printf(\"\\n离开车辆的车牌号为:%d\//输出离开车场的车牌号

printf(\"\\n到达时间为: %d点\ printf(\"\\n离开时间为: %d点\ a=p.Atime; b=p.Dtime;

printf(\"\\n应交费用为: %d元\计算并输出停车费用 printf(\"\\n**********************************\\n\"); }

算法思想：当汽车离开停车场时，调用此函数，输入汽车离开车场的时间，便打印该汽车的车牌号、到达时间、离开时间和缴纳费用等信息，来模拟汽车离开停车场。（n为当前的时间） 程序框图： 打印汽车车牌号 汽车离开信息（p） int a,b 打印汽车到达时间 while(1) 打印汽车离开时间 Y 输入：p.Dtime 打印应交费用 N p.Dtime>24 || p.Dtimeint i,j=1,k=0; long NO; CarNode p,t; QNode *q;

if(car1->top>0) //停车场内有车辆停放 {

while(j) {

printf(\"\\n请输入离开停车场车辆的车牌号：\"); scanf(\"%d\

for(i=1;i<=car1->top;i++) //查找停车场内是否存在该车牌号

{

if(car1->stack[i].CarNo==NO)

k=1; //存在，k=1 } if(k) {

while(car1->stack[car1->top].CarNo!=NO) //当停车场top位置停放的车牌号不为NO时，将该位置的车开入临时停车场 {

Temp->top++;

Temp->stack[Temp->top]=car1->stack[car1->top]; //入栈。临时车场栈顶指针+1,把车停放在临时车场

car1->top--; //出栈。原车场的栈顶置空，栈顶指针-1 }

p=car1->stack[car1->top]; //将要离开停车场的车辆信息赋给p

car1->top--; //栈顶-1 j=0; //结束while } else

printf(\"无此车牌号码，请重新输入!\"); }

output(p); //调用汽车离开停车场的信息函数

while(Temp->top>=1) //将临时车场里的车停回到停车场 {

car1->top++;

car1->stack[car1->top]=Temp->stack[Temp->top]; Temp->top--; }

if(n>=24) {

printf(\"\\n****已过24点，停车场管理系统关闭!****\\n\"); m=0; } else {

if((car2->front!=car2->rear)&&car1->topq=car2->front->next; //取队首结点q

t=q->data; //拷贝队首结点的车辆信息 car1->top++;

printf(\"\\n便道的%d号车进入车场第%d位置!\ while(1) {

printf(\"\\n请输入%d号车进入车场的时间(%d~23点):\

scanf(\"%d\输入车到达停车场的时间 if(t.Atime>23 || t.Atimeprintf(\"输入时间有误，请重新输入!\"); else {

n=t.Atime;

printf(\"\\n北京时间%d:00整\\n\ break; } }

car2->front->next=q->next; //修改队首指针

if(q==car2->rear) car2->rear=car2->front; /* 当队列只有一个结点时应防止丢失队尾指针 */

car1->stack[car1->top]=t; //车进入停车场 free(q); }

else printf(\"\\n便道里没有车\\n\"); //便道没有车，end if } }

else printf(\"\\n车场里没有车\\n\"); //停车场内没有车，end if }

算法思想：当顺序栈不为空时，进行汽车要离开停车场操作，输入要离开的车牌号，匹配顺序栈的数组中是否存在该车牌号的元素（如果未找到，则提示车牌号输入错误，重新输入），如果其他的汽车需要为从停车场离开的车让路的话，则把这些车暂时存放在另一个顺序栈，待该车离开后，再按原次序返回停车场。如果便道里有车在等候，则将该车开入停车场停放。当停车场内没车停放时，则提示停车场没有车，不能进行离开停车场操作。

程序框图： 汽车离开停车场 N 停车场有车？ Y 需让路的车进入临时停车场，输入离开停车场的车牌号 无需让路直接进行下一步操 Y 判断车场是否调用车辆离开停 存在此车牌号 车场信息函数 N 临时停车场的车 返回停车场 无此车牌号， 重新输入 便道是否有 车在等候？ N Y 便道的第一辆 提示：便道车进入停车场 里没有车 结束

5）void List1(StackCar *car1) //打印停车场的车辆 {

int i;

if(car1->top>0) {

printf(\"\\n车场:\");

printf(\"\\n车牌号\到达时间\\n\"); for(i=1;i<=car1->top;i++) {

提示：车场里没有车！

printf(\"%d\

printf(\"\%d点\\n\ } }

else printf(\"\\n车场里没有车!\\n\"); }

算法思想：打印栈中的元素，通过一个单循环，打印栈1-top中的元素（车牌号）。 程序框图： StackCar *car1 int i N car1->top >0？ 打印：车场里没有车！ Y i=1 N i<=car结束 1->top Y 打印车牌号和到达时间 6）void List2(LinkQueue *car2) //打印便道中等候的车辆 {

QNode *p;

p=car2->front->next;

if(car2->front!=car2->rear) {

printf(\"\\n便道:\\n车牌号 \"); while(p!=NULL) {

printf(\"%d\\ p=p->next; } }

else printf(\"\\n便道里没有车!\\n\");

}

算法思想：通过队列的队首指针，一一打印队列中的元素。 程序框图： List2(LinkQueue *car2) QNode *p p=car2->front->next N car2->front!=提示：便道里没有车 car2->rear？ Y 结束 p!=NULL N Y 打印车牌号

7）/*主函数*/ void main() {

StackCar car1,temp; //定义两个堆栈，停车场car1，临时停车场car2 LinkQueue *car2; //定义一个队列，用于便道停放等候停车的车辆 char choose; //选项 StackInitiate(&car1); StackInitiate(&temp); car2=Init_LinkQueue();

printf(\"=================欢迎光临Wings停车场=====================\\n\" );

printf(\"*入场须知:本停车场内设 %d个停车位,停车收费为每小时 %d元, *\\n\

printf(\"* 停车超过半小时按一小时计算,不超过不收费. *\\n\");

printf(\"* 营业时间:24小时 *\\n\");

printf(\"* 投诉监督电话:123-456789 *\\n\");

printf(\"*停车系统提示:只供模拟一天的汽车停放情况 *\\n\");

printf(\"=================欢迎光临Wings停车场=====================\\n\" );

while(m) {

printf(\"\\n 停车场管理程序 \\n\"); printf(\"===============================================\\n\"); printf(\"** A 汽车到达停车场 **\\n\"); printf(\"** **\\n\"); printf(\"** D 汽车离开停车场 **\\n\"); printf(\"** **\\n\"); printf(\"** F 汽车停靠信息 **\\n\"); printf(\"** **\\n\"); printf(\"** E 退出程序 **\\n\"); printf(\"===============================================\\n\"); printf(\"请选择(A,D,F,E): \"); scanf(\"%c\ switch(choose) {

case 'A': case 'a':

Arrival(&car1,car2);//车进入停车场 break; case 'D': case 'd':

Departure(&car1,&temp,car2); break; //车离开停车场 case 'F': case 'f':

printf(\"\\n-----------汽车停靠信息一览表-------------\"); List1(&car1); List2(car2);

printf(\"\\n------------------------------------------\"); break; case 'E': case 'e': m=0; break; default:

printf(\"无此选项，请重新输入!\\n\");

break; }

while (choose!= '\\n') scanf(\"%c\ } }

算法思想：设计菜单，进行停车场的各项操作。 程序框图：

A选项 调用汽车进入停车 场函数 Arrival(&car1,car2) break 主函数main() StackCar car1,temp LinkQueue *car2 char choose 调用初始化函数 StackInitiate(&car1) StackInitiate(&temp) car2=Init_LinkQueue() 打印汽车停车须知等信息 菜单选择（choose） D选项 调用汽车离开停车场函数 Departure(&car1,&temp,car2) F选项 E选项 调用汽车停靠查询函数 List1(&car1);List2(car2) 退出选择菜单，结束程序 结束