停车场管理课程设计报告

停车场管理
一、课程设计题目内容
(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 *n ext; // 数据域指针域
}QNode;
typedef struct Node // {
QNode *fron t; //
QNode *rear; //
用队列定义，构造停车场外的等候便道
队头指针
队尾指针
}Lin
kQueue;
四、所设计的函数
1)void StackInitiate(StackCar *s) // 堆栈初始化
{
s->top=0; // 栈顶置0
}
初始方法：初始化顺序栈，只需令栈顶的下标值置为0即可程序框图：
堆栈的初始化(s)
2) LinkQueue *lnit_LinkQueue(void)// 链队列的初始化
{ _
Lin kQueue *Q;QNode *p;
p=(QNode *)malloc(sizeof(QNode)) ; /* 开辟头结点*/
p-> next=NULL;
Q=(Li nkQueue *)malloc(sizeof(Li nkQueue));/* 开辟链队的指针结点*/
Q->fron t=Q->rear=p;
return(Q);
}
初始方法：开辟一个队列的头结点p,其next指针为空，再开辟链队的指针结点Q,用p来初始化链队结点的队头指针和队尾指针。

初始化成功后，返回Q
程序框图：
队列的初始化
初始化成功
3) void
Arrival(StackCar *car1,LinkQueue *car2) // 车辆进入停车场操
作
{
CarNode p;
QNode *q;
prin tf("\n++++++++++++ 车辆至U达登记表+++++++++++");
printf("\n 请输入车牌号(整型，例如：1234):");
sca nf("%d",&p.CarNo);〃输入车牌号
if(car1->top<Maxsize) // 停车场未停满车时，即栈未满，进入停车场
{ car1->top++; // 栈顶指针+1 printf("\n 【汽车顺利停放在车场的第％c位置】\n",car1->top);
while(1)
{
printf("\n 车辆几点钟到达(％d~23点):",n);
scanf("%d",&p.Atime);
if(p.Atime>23 || p.Atime<n)
printf(" 输入时间有误，请重新输入!"); else {
n=p.Atime;
printf("\n 北京时间％d:00整\n",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,L in kQueue *car2)
4) void output(CarNode p) // 输出车离开停车场离开时间、收费等信息{
int a,b;
while(1)
{
printf("\n 车辆离开的时间(%d点~24点之间的时间):",n);
scan f("%d",&(p.Dtime)); // 输入车辆离开的小时、分钟
if(p.Dtime>24 || p.Dtime<n)
printf(" 输入时间不符合，重新输入！",p.Atime);
else
4)void Departure(StackCar *car1,StackCar *Temp,LinkQueue *car2) // 车辆离开停车场
操作
{
n=p.Dtime;
prin tf("\n break; 北京时间%d:00整\n",n); }
}
prin tf("\n ********** prin tf("\n
离
//输出离开车场的车牌号
**********“ 车辆离开信息表**********");
开车 辆的车 牌号为 ：％d",p.CarNo);
printf("\n 到达时间为:%d 点",p.Atime); printf("\n 离开时间为:%d 点”,p.Dtime); a=p.Atime; b=p.Dtime;
printf("\n 应交费用为:%4元",(b-a)*price);
//
计算并输出停车费用
prin tf("\n ********************************
**\n"); }
算法思想：当汽车离开停车场时，调用此函数，输入汽车离开车场的时间， 便打印该汽车的车牌号、到达时间、离开时间和缴纳费用等信息，来模拟汽车离 开停车场。

(n 为当前的时间) 程序框图：
{int i,j=1,k=0; long NO; CarNode p,t; QNode *q;
if(car1->top>0) // 停车场内有车辆停放 {
while(j)
{
printf("\n 请输入离开停车场车辆的车牌号： "); scanf("%d",&NO);
牌号
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]; //
car1->top--; //
j=0; //
else
printf(" 无此车牌号码，请重新输入 !");
}
output(p); // 调用汽车离开停车场的信息函数
while(Temp->top>=1)
//
将临时车场里的车停回到停车场
{
car1->top++; car1->stack[car1->top]=Temp->stack[Temp->top]; Temp->top--; }
if(n>=24)
信息赋给 p
将要离开停车场的车辆 栈顶-1 结束 while
printf("\n**** 已过24 点，停车场管理系统关闭!****\n");
m=0;
}
else
{
if((car2->front!=car2->rear)&&car1->top<Maxsize) // 如果有车在便道等候，将车停入停车场
{
q=car2->front->next; // 取队首结点q t=q->data; // 拷贝队首结点的车辆信息
car1->top++;
printf("\n 便道的%d 号车进入车场第%d 位
置!",t.CarNo,car1->top);
while(1)
{
printf("\n 请输入%d 号车进入车场的时间(%d~23 点):",t.CarNo, n);
scanf("%d",&(t.Atime)); // 输入车到达停车场的时间if(t.Atime>23 ||
t.Atime<n)
printf(" 输入时间有误，请重新输入!");
else
{
n=t.Atime;
printf("\n 北京时间％d:00整\n",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
}
算法思想：当顺序栈不为空时，进行汽车要离开停车场操作，输入要离开的车牌号，匹配顺序栈的数组中是否存在该车牌号的元素(如果未找到，则提示车牌号输入错误，重新输入)，如果其他的汽车需要为从停车场离开的车让路的话，则把这些车暂时存放在另一个顺序栈，待该车离开后，再按原次序返回停车场。

如果便道里有车在等候，则将该车开入停车场停放。

当停车场内没车停放时，则提示停车场没有车，不能进行离开停车场操作。

程序框图:
5) void List1(StackCar *car1) // 打印停车场的车辆{
int i;
if(car1->top>0)
{
prin tf("\n 车场:");
printf("\n 车牌号\t到达时间\n");
for(i=1;i<=car1->top;i++)
{
}prin tf("%d",car1->stack[i].CarNo);
prin tf("\t%d 点\n",car1->stack[i].Atime);
} else printf("\n 车场里没有车!\n");
}
算法思想：打印栈中的元素，通过一个单循环，打印栈1-top中的元素(车牌号) 程序框图：
6)void List2(LinkQueue *car2) // 打印便道中等候的车辆
{
QNode *p;
p=car2->front->n ext;
if(car2->fron t!=car2->rear)
{
printf("\n 便道:\n 车牌号");
while(p!=NULL)
{
prin tf("%d\t",p->data.CarNo);
p=p->n ext;
}
}
else printf("\n 便道里没有车!\n");
定义两个堆栈，停车场car1，临时停车场car2 定义一个队列，用于便道停放等候停车的车辆 选项
StackI ni tiate(&car1); StackI ni tiate(&temp); car2=l nit_Li nkQueue();
prin tf("================= 欢 迎 光 临 Wings 停
车 场
=====================\n");
printf("* 入场须知：本停车场内设%d 个停车位，停车收费为每小时%d 元,
*\n");
营业时间:24小时
*\n");
打印队列中的元素
7) /*主函数*/ void mai n() {
StackCar car1,temp; // Lin kQueue *car2; // char choose; //
*\n ”,Maxsize,price)
; prin tf("*
停车超过半小时按一小时计算，不超过不收费.
prin tf("*
}
算法思想：通过队列的队首指针, 程序框图：
printf("* 投诉监督电话 :123-456789 *\n");
printf("* 停 车 系 统 提 示 : 只 供 模 拟 一 天 的 汽 车 停 放 情 况 *\n"); printf("================= 欢 迎 光 临 Wings 停 车 场 =====================\n" );
while(m)
scanf("%c",&choose); 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");
printf("\n printf(" printf("** A printf("** printf("** D printf("**
printf("** F printf("** printf("** E
停车场管理程序 汽车到达停车场
**\n");
汽车离开停车场
**\n");
汽车停靠信息
**\n");
退出程序
printf("===================== printf(" 请选择(A,D,F,E):"); \n");
========\n");
**\n");
**\n"); **\n"); **\n");
========\n");
break;
}
while (choose!= '\n') scan f("%c",&choose); } }
算法思想：设计菜单，进行停车场的各项操作。

程序框图：
主函数main()
StackCar car1,temp
Lin kQueue *car2
char choose
调用初始化函数 StackI ni tiate(&car1)
StackI ni tiate( &temp) car2=I ni t_Li nkQueue()
(choose )
1 F
f
A
结束
break
A 选项
D 选项
1 !
4
F 选项
E 选项
Arrival (&car1,car2)
Departure (&car1, &temp,car2)
调用汽车停靠查询函数 List1(&car1);List2(ca r2)
退出选择菜 单，结束程序
打印汽车停车 须知等信息
调用汽车离开停车场函数 调用汽车进入停车 场函数。