停车场管理系统(数据结构。C语言版)

//设停车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。
//汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列(大门在最南端，最先到达的第一辆车停放在车场的最北端)，

//若车场内已停满n辆汽车，则后来的车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；
//当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车长为它让路，待该车开出大门外，

//其他车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。
//基本要求：以栈模拟停车场，以队列模拟车场外的便道
//部分源代码(栈和队列的数据结构自己定义，在清华版的数据结构课本上有详细的描述)
//停车场管理系统
//停车场管理系统
#include<stdio.h>
typedefstructCar{
//结构体：车辆Car
intnumber;
intinTime;
intoutTime;
}Car;

typedefCarUser;//用户自定义类型

#defineFEIYONG0.05//停车费用单价

#define MAXSIZE5//停车场容量


//--------------系统库函数------------------
#include"stdlib.h"
//--------------通用变量、常量、类型声明------------------
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineOVERFLOW-2

typedefintStatus;
typedefUserSElemType;

//---------------存储表示---------------------
#defineSTACK_INIT_SIZE100
#defineSTACKINCREMENT10
typedefstruct{
SElemType*base;
SElemType*top;
intstacksize;
}SqStack;
//---------------函数原型---------------------
//StatusInitStack(SqStack &S);
//构造空栈
//StatusDestroyStack(SqStack &S);
//销毁栈S
//StatusClearStack(SqStack &S);
//置空
//StatusStackEmpty(SqStack S);
//判空；空：TRUE，不空：FALSE。
//intStackLength(SqStack S);
//返回S的元素的个数，即栈的长度。
//StatusGetTop(SqStack S,SElemType &e);
//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR。
//StatusPush(SqStack &S,SElemType e);
//插入元素e为新的栈顶元素
//StatusPop(SqStack &S,SElemType &e);
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR。
//StatusStackTraverse(SqStack S,Status ( * visit)());
//从栈底到栈顶依次对栈中每个元素调用函数visit()。一旦visit()失败，则操作失败。


//---------------基本操作---------------------
Status InitStack(SqStack &S) {
//构造空栈
S.base = (SElemType * )malloc(STACK_INIT_SIZE * sizeof(SElemType));
if(!S.base)exit(OVERFLOW);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
returnOK;
}//InitStack

St
atus DestroyStack(SqStack &S){
//销毁栈S
free(S.base);
returnOK;
}//DestroyStack

Status ClearStack(SqStack &S){
//置空
returnOK;

}//ClearStack

//StatusClearStack(SqStack &S);
//置空

StatusStackEmpty(SqStack S){
//判空；空：TRUE，不空：FALSE。
if(S.top == S.base)returnTRUE;
elsereturnFALSE;
}//QueueEmpty

intStackLength(SqStack S){
//返回S的元素的个数，即栈的长度。
returnS.top - S.base;
}

Status GetTop(SqStack S,SElemType &e){
//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR。
if(S.top == S.base)returnERROR;
e = *(S.top-1);
returnOK;
}//GetTop

Status Push(SqStack &S,SElemType e){
//插入元素e为新的栈顶元素
if(S.top - S.base >= S.stacksize){//栈满，追加存储空间
S.base = (SElemType *)realloc(S.base,
(S.stacksize + STACKINCREMENT) * sizeof(SElemType));
if(!S.base)exit(OVERFLOW);//存储分配失败
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
returnOK;
}//Push

Status Pop(SqStack &S,SElemType &e){
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR。
if(S.top == S.base)returnERROR;
e = * --S.top;
returnOK;
}//Pop

StatusStackTraverse(SqStack S){//,Status ( * visit)()){
//从栈底到栈顶依次对栈S中每个元素调用函数visit()。一旦visit()失败，则操作失败。
for(SElemType*p = S.base; p < S.top; p++)
printf("%d\n",p->number);
returnOK;
}//StackTraverse


typedefintStatus;
typedefUserQElemType;

//---------------存储表示---------------------
typedefstructQNode {
QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct {
QueuePtrfront;
QueuePtrrear;
}LinkQueue;

//---------------函数原型---------------------
//StatusInitQueue(LinkQueue &Q);
//构造空队列Q
//StatusDestroyQueue(LinkQueue &Q);
//销毁队列Q
//StatusClearQueue(LinkQueue &Q);
//置空
//StatusQueueEmpty(LinkQueue Q);
//判空；空：TRUE，不空：FALSE。
//intQueueLength(LinkQueue Q);
//返回S的元素的个数，即队列的长度。
//StatusGetHead(LinkQueue Q,QElemType &e);
//若队列不空，则用e返回S的队头元素，并返回OK；否则返回ERROR。
//StatusEnQueue(LinkQueue &Q,QElemType e);
//插入元素e为新的队尾元素
//StatusDeQueue(LinkQueue &Q,QElemType &e);
//若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR。
//StatusQueueTraverse(LinkQueue Q,Status ( * visit)());
//从队头到队尾依次对队列Q中每个元素调用函数visit()。一旦visit()失败，则操作失败。


//---------------基本操作---------------------
StatusInitQueue(LinkQueue &Q){
//构造空队列Q
Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
if(!Q.front)exit(OVERFLOW);
Q.front->next = NULL;
returnOK;
}//InitQueue


StatusDestroyQueue(LinkQueue &Q){
//销毁队列Q
while(Q.front){
Q.rear = Q.front->next;
free(Q.front);
Q.front = Q.rear;
}
returnOK

;
}//DestroyQueue

//StatusClearQueue(LinkQueue &Q);
//置空

StatusQueueEmpty(LinkQueue Q){
//判空；空：TRUE，不空：FALSE。
if(Q.front == Q.rear)returnTRUE;
elsereturnFALSE;
}//QueueEmpty

//intQueueLength(LinkQueue Q);
//返回Q的元素的个数，即队列的长度。

StatusGetHead(LinkQueue Q,QElemType &e){
//若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR。
if(Q.front == Q.rear)returnERROR;
e = Q.front->next->data;
returnOK;
}//GetHead

StatusEnQueue(LinkQueue &Q,QElemType e){
//插入元素e为新的队尾元素
QueuePtrp;
p = (QueuePtr)malloc(sizeof(QNode));
if(!p)exit(OVERFLOW);
p->data = e;p->next = NULL;
Q.rear->next = p;
Q.rear = p;
returnOK;
}//EnQueue

StatusDeQueue(LinkQueue &Q,QElemType &e){
//若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR。
QueuePtrp;
if(Q.front == Q.rear)returnERROR;
p = Q.front->next;
e = p->data;
Q.front->next = p->next;
if(Q.rear == p)Q.rear = Q.front;
free(p);
returnOK;
}//DeQueue

StatusQueueTraverse(LinkQueue Q){//,Status ( * visit)()){
//从队头到队尾依次对队列Q中每个元素调用函数visit()。一旦visit()失败，则操作失败。
for(QueuePtrp = Q.front->next; p !=NULL; p = p->next)
printf("%d\n",p->data.number);
returnOK;
}//QueueTraverse



//函数声明部分
voidWelcome();//主选项画面
voidGoIn();//进场部分
intGoOut();//出场部分
voidLookChang(); //查看停车场部分
voidLookDao();//查看便道部分
voidLookCopyRight();//查看版权信息

//全局变量声明
SqStackS1,S2;//S1为停车场，S2为暂存的地方
LinkQueueQ;//Q为便道

void Welcome(){
//主选项画面
//clrscr();
printf("****************欢迎使用停车场管理系统****************\n");
printf(" 请选择以下功能：\n\n");
printf(" 1. 车辆到达\n");
printf(" 2. 车辆离去\n");
printf(" 3. 查看停车场内情况\n");
printf(" 4. 查看便道情况\n");
printf(" 5. 退出\n\n");
printf("****************Made by YanJingTu2008*****************\n");
printf("请输入1~6之间的数字选择相应功能：");
}//Welcome

voidGoIn(){
//进场部分
Care;
printf("您选择的是 1.车辆到达\n");
printf("请输入车号：");
scanf("%d",&e.number);
printf("请输入到达时间(格式:HHMM)：");
scanf("%d",&e.inTime);
inti = StackLength(S1);
if(i >= MAXSIZE){//停车场内已满，车辆在便道等待
printf("\n停车场内已满，请在便道内等待！\n\n");
EnQueue(Q,e);
}else{//停车场没满，车辆进入

Push(S1,e);
printf("\n车辆%d已于%d时%d分停放在第%d位。\n\n",\
e.number,e.inTime/100,e.inTime-e.inTime/100*100,i+1);
//e.inTime / 100 为车辆进入停车场的时

间（小时）
//e.inTime - e.inTime / 100 * 100 为车辆进入停车场的时间（分钟）
//i+1 为停车位
}
}//GoIn

intGoOut(){
//出场部分
intCarNum;//车号
SElemType*CarID;//车辆在停车场中的位置，指向停车场栈的基址指针
printf("您选择的是 2.车辆离去\n");
if(StackEmpty(S1) == TRUE)
printf("停车场内没有车辆！\n\n");//看停车场内是否有车
else{
//车辆离开
printf("请输入要离开的车辆的车号：");
scanf("%d",&CarNum);
for(CarID = S1.base; CarID < S1.top; CarID++)//遍历，检查输入的车号
if(CarID->number == CarNum)break;
if(CarID == S1.top)//没有这辆车
printf("对不起，没有这辆车！请检查您输入的车号：%d\n\n",CarNum);
else//找到这辆车了，让其离开停车场
{
printf("车辆%d进入停车场的时间是(格式:HHMM)：%d",CarID->number,CarID->inTime);
printf("\n请输入车辆离开的时间(格式:HHMM)：");
scanf("%d",&CarID->outTime);
if(CarID->outTime <= CarID->inTime)
{
printf("\n时间不正确，离开时间居然会早于到达时间？！\n\n");
return 0;
}
//计算费用，输出费用
inthh1,hh2,mm1,mm2,hh,mm;
floatmoney;//停车金额
hh1 = CarID->inTime / 100;
mm1 = CarID->inTime - hh1 * 100;
hh2 = CarID->outTime / 100;
mm2 = CarID->outTime - hh2 * 100;
if(mm2 - mm1 <0)
{
hh2--;
mm2+=60;
}
hh = hh2 - hh1;
mm = mm2 - mm1;
money = (float)((hh * 60 + mm) * FEIYONG);////费用四舍五入
printf("您本次的停车费用为 %2.1f 元。谢谢使用。\n\n", money);
//车辆出栈(该车后面的车先出栈并入栈S2暂存)
SElemTypee;
Pop(S1,e);
while(e.number != CarID->number || e.inTime != CarID->inTime)
{
Push(S2,e);
Pop(S1,e);
}
while(!StackEmpty(S2))
{
Pop(S2,e);
Push(S1,e);
}
//检查便道中是否有车辆，有的话第一辆车出队列并入栈S1
if(!QueueEmpty(Q))
{
DeQueue(Q,e);
e.inTime = hh2 * 100 + mm2;
Push(S1,e);
//显示提示：便道中的车进入停车场
printf("便道中的第一辆车%d于%d时%d分进入停车场！\n\n",e.number,hh2,mm2);
}
}
}
return0;
}//GoOut

voidLookChang(){
//查看停车场部分
printf("您选择的是 3.查看停车场内情况\n");
StackTraverse(S1);
printf("\n");
}//LookChang

voidLookDao(){
//查看便道部分
printf("您选择的是 4.查看便道情况\n");
QueueTraverse(Q);
printf("\n");
}//LookDao



intmain(){
//主函数
InitStack(S1);//初始化S1
InitStack(S2);//初始化S2
InitQueue(Q);//初始化Q
while(1){
Welcome();
char i = ge
tchar();//获取按键(主菜单)
if(i == 10)i = getchar();//清空字符缓冲区
char i2 = getchar();
while(i2 != 10)i2 = getchar();//清空字符缓冲区
switch(i){
ca

se '1':
//选择进场
GoIn();break;
case '2':
//选择出场
GoOut();break;
case '3':
//选择查看场内情况
LookChang();break;
case '4':
//选择查看便道情况
LookDao();break;
case '5':
//退出
printf("程序已退出！谢谢使用！\n\n");
exit(0);
break;
default:
//其它
printf("您必须选择1~5之间的数字！\n");
}
}//while(1)
DestroyStack(S1);
DestroyStack(S2);
DestroyQueue(Q);
return0;
}