锐客网

  1. 首页 > it技术 > >

数据结构 停车场管理系统（附源码）C++ 团队接课设、毕设 zhao835231559@126.com



模拟停车场管理问题

问题描述：

设停车场只有一个可停放几辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场按车辆到来的先后顺序依次排列，若车场内已停满几辆汽车，则后来的汽车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可进入；当停车场内某辆车要离开时，由于停车场是狭长的通道，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门后，为它让路的车辆再按原次序进入车场。每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。
基本要求：
试为停车场编制按上述要求进行管理的模拟程序。在这里假设汽车不能从便道上开走。试设计一个停车场管理程序。
实现提示：
以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻，例如：('A',1,5)表示一号牌照车在5这个时刻到达，而('D',5,20)表示5号牌照车在20这个时刻离去，整个程序可以在输入信息为('E',0,0)时结束。对每一组输入数据进行操作后的输出数据为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车离去；则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。栈以顺序结构实现，队列以链表实现。需另设一个栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车。
1.设计题目：《停车管理系统》
2.设计目的：
（1）根据车辆到达停车场到车辆离开停车场时所停留的时间进行计时收费。
（2）当有车辆从停车场离开时，等待的车辆按顺序进入停车场停放。实现停车场的调度功能。
（3）用顺序栈来表示停车场，链队表示停车场外的便道。
（4）显示停车场信息和便道信息。
（5）操作提示界面。
算法思想分析
（1）、模拟停车场的车辆进出需要输入车辆的信息，比如车辆的车牌号码、自动匹配本地时间，因此，可以定义一个车辆信息结点类型和一个时间节点类型，在链式栈、链式队列中定义结点类型为车辆信息结点类型。
（2）、车辆离开时，需要打印输出车辆的车位号、到达时间、离开时间以及应缴纳的费用。定义expenses函数实现。
（3）、车辆到达时要输入车辆的信息，并以此存放在停车场内；每进入一辆车，要判断停车场（链式栈）是否已经停满，若已满，则提示该车要在便道上等待；若未满，则进行进栈操作。
（4）、车辆的离开，要另外设计一个辅助栈，当一辆汽车要离开时，在其后的车辆要给其让路，让路的汽车就暂时停放在这个栈中。车辆离开后，要判断便道上是否有车辆在等待，若有则进行入栈操作，即将车辆的信息结点进行入栈操作。
（5）、车辆的查询，既可以查询停车场内的车辆，也可以查询便道上等待的车辆，查询显示车辆的当前情况。
算法思想分析
（1）、模拟停车场的车辆进出需要输入车辆的信息，比如车辆的车牌号码、自动匹配本地时间，因此，可以定义一个车辆信息结点类型和一个时间节点类型，在链式栈、链式队列中定义结点类型为车辆信息结点类型。
（2）、车辆离开时，需要打印输出车辆的车位号、到达时间、离开时间以及应缴纳的费用。定义expenses函数实现。
（3）、车辆到达时要输入车辆的信息，并以此存放在停车场内；每进入一辆车，要判断停车场（链式栈）是否已经停满，若已满，则提示该车要在便道上等待；若未满，则进行进栈操作。
（4）、车辆的离开，要另外设计一个辅助栈，当一辆汽车要离开时，在其后的车辆要给其让路，让路的汽车就暂时停放在这个栈中。车辆离开后，要判断便道上是否有车辆在等待，若有则进行入栈操作，即将车辆的信息结点进行入栈操作。

（5）、车辆的查询，既可以查询停车场内的车辆，也可以查询便道上等待的车辆，查询显示车辆的当前情况。
数据结构 停车场管理系统（附源码）C++ 团队接课设、毕设 zhao835231559@126.com
文章图片


算法思想分析
（1）、模拟停车场的车辆进出需要输入车辆的信息，比如车辆的车牌号码、自动匹配本地时间，因此，可以定义一个车辆信息结点类型和一个时间节点类型，在链式栈、链式队列中定义结点类型为车辆信息结点类型。
（2）、车辆离开时，需要打印输出车辆的车位号、到达时间、离开时间以及应缴纳的费用。定义expenses函数实现。
（3）、车辆到达时要输入车辆的信息，并以此存放在停车场内；每进入一辆车，要判断停车场（链式栈）是否已经停满，若已满，则提示该车要在便道上等待；若未满，则进行进栈操作。
（4）、车辆的离开，要另外设计一个辅助栈，当一辆汽车要离开时，在其后的车辆要给其让路，让路的汽车就暂时停放在这个栈中。车辆离开后，要判断便道上是否有车辆在等待，若有则进行入栈操作，即将车辆的信息结点进行入栈操作。
（5）、车辆的查询，既可以查询停车场内的车辆，也可以查询便道上等待的车辆，查询显示车辆的当前情况。



五、算法主要功能函数及实现
typedef struct//时间结构图
{
int day;
int hour;
int min;
int sec;
}TIME; //时间结点
typedef struct
{
char num[10]; //车牌号
TIME time; //进入停车场的时间
int n; //进入停车场的位置
}information;

typedef struct node
{
information data;
struct node *next;
}stacknode; stacknode *top1,*top2,*top3; //栈结构体定义



typedef struct
{
information data;
stacknode *front,*rear;
}LQueue; LQueue *Q; //队列结构体定义
stacknode *into(stacknode *top1,LQueue *Q); //初始化车辆进入
{
time_t rawtime; //调用系统时间函数
struct tm *timeinfo; //时间结点
time( &rawtime);
timeinfo = localtime( &rawtime);
p = (stacknode *)malloc(sizeof(stacknode));
if(p == NULL)
{
printf(" 内存分配失败");
return top1;
}
printf(" 请输入进入停车场车辆的车牌号:");
scanf("%s", p->data.num);
q = top1;
while(q!= NULL)
{
if(strcmp(p->data.num, q->data.num) == 0)
{
printf("车牌号输入有误，该车已进入!");
return top1;
}
q = q->next;
}
p->data.time.day= timeinfo->tm_mday;
p->data.time.hour = timeinfo->tm_hour;
p->data.n = b;
if(b > maxs)
{
printf("停车场已满,请在便道等候!\n");
wait(Q,p);
return top1;
}
if(top1 == NULL)
{
p->next = NULL;
top1 = p;

}
else
{
p->next = top1;
top1 = p;
}
b++;
printf("车牌为%s的汽车驶入时间为:%d号%d点%d分%d秒\n",top1->data.num,);
return top1;
}
int expenses(stacknode *p,int x,int y); //停车费用计算函数
{
if(x3!= 0)
w = (x1*24+x2+1-(p->data.time.day*24+p->data.time.hour))*price;
else
w = (x1*24+x2-(p->data.time.day*24+p->data.time.hour))*price;
return w;
}
stacknode *leave(stacknode *top1,char str[],LQueue *Q); {//车辆驶出出场函数
if(top1 == NULL)
{printf("停车场没有车辆!\n"); return top1; }
q = (stacknode *)malloc(sizeof(stacknode));
if(p == NULL)
{printf("内存分配失败"); return top1; }
q = top1;
while(q!= NULL)
{if(strcmp(q->data.num,str) == 0)
break;
q = q->next; }
{printf("输入有误，该车辆不在停车场!\n");
if(q == NULL)
return top1; }
for(i = top1->data.n; i > q->data.n; i--)
{p = (stacknode *)malloc(sizeof(stacknode));
strcpy(p->data.num,top1->data.num);
p->data.time = top1->data.time;
p->data.n= top1->data.n-1;
top1 = top1->next;
if(top2 == NULL)
{p->next = NULL; top2 = p; }
else
{p->next = top2; top2 = p; }}
top1 = top1->next;
while( top2!= NULL)
{p=(stacknode*)malloc(sizeof(stacknode)); if(p==NULL){printf("内存分配失败"); return top1; }
p->data.n = top2->data.n;
strcpy(p->data.num,top2->data.num);
p->data.time = top2->data.time;
p->next = top1;
top1 = p;
top2 = top2->next; }
if(EmptyLQue(Q))
{p = out(Q); p->data.n--; top1 = LQinto(p,top1); }
else b--;
printf("车牌为%s的汽车驶出时间为:%d号%d点%d分%d秒\n",q->data.num,);
printf("汽车停留的时间为%f小时\n",time(q));
printf("车辆驶出停车场需要缴纳的费用为:%d元\n",expenses(q)); return top1; }
LQueue *wait(LQueue *q,stacknode *s); //车辆进入候车便道函数
{s->next = NULL; q->rear->next = s; q->rear = s; return q; }
int EmptyLQue(LQueue *q); //判断候车便道有无等待车辆函数
stacknode *out(LQueue *q); //候车区车辆出队
{ p = q->front->next;
if(q->front->next == q->rear)
{q->rear = q->front; return p; }
else
q->front->next = p->next; p->next = NULL; return p; }
stacknode *LQinto(stacknode *p,stacknode *top1); {//从候车便道进入停车场函数 p->next = top1; top1 = p; return top1; }
void show(stacknode *top1); //显示停车场所有信息函数
{ printf("停车场内全部车辆信息表\n");
if(top1 == NULL)
printf("停车场内无车!\n");


else
{
printf("车牌号进入时间位置\n");
while(top1!= NULL)
{printf(" %s%d号%d点%d分第%d位\n",top1->data.num,); top1 = top1->next; }} }
void T_shou(LQueue *Q); //显示候车区信息

double time(stacknode *p,int x1,int x2,int x3,int x4); //计算停留时间
{ q = (LQueue *)malloc(sizeof(LQueue)); q ->front = Q->front;
q ->rear= Q->rear; printf("候车区信息\n"); if(q->front == q->rear)
printf("候车区没有车辆!\n");
else
{q->front = q->front->next; printf("车牌号进入时间\n"); while(q->front!= NULL)
{printf("%s %d号%d点%d分 \n",q->front->data.num,q->front->data.time.day,q->front->data.time.hour,q->front->data.time.min); q->front = q->front->next; }

全部源码：

#include
#include
#include
#include
#include
#definemaxs 3//最大停车数量
#define price 1//天气晴朗资费
#define prices 3//天气恶略资费
int b=1; //计数
typedef struct//时间结构图
{
int day;
int hour;
int min;
int sec;
}TIME; //时间结点
typedef struct
{
char num[10]; //车牌号
TIME time; //进入停车场的时间
int n; //进入停车场的位置
}information;
typedef struct node
{
information data;
struct node *next;
}stacknode; stacknode *top1,*top2,*top3; //栈结构体定义


typedef struct
{
information data;
stacknode *front,*rear;
}LQueue; LQueue *Q; //队列结构体定义

stacknode *Init(); //栈的初始化
stacknode *into(stacknode *top1,LQueue *Q); //初始化车辆进入
int expenses(stacknode *p,int x,int y); //停车费用计算函数
stacknode *leave(stacknode *top1,char str[],LQueue *Q,int weather_1); //车辆驶出出场函数
LQueue *InitLQue(); //初始化队列函数
LQueue *wait(LQueue *q,stacknode *s); //车辆进入候车便道函数
int EmptyLQue(LQueue *q); //判断候车便道有无等待车辆函数
stacknode *out(LQueue *q); //候车区车辆出队
stacknode *LQinto(stacknode *p,stacknode *top1); //从候车便道进入停车场函数
void show(stacknode *top1); //显示停车场所有信息函数
void T_shou(LQueue *Q); //显示候车区信息
double time(stacknode *p,int x1,int x2,int x3,int x4); //计算停留时间
int weather(); //天气判断
void key(); //密码
int vip(stacknode *s); //vip用户
stacknode *booking(stacknode *top1); //预约

//主函数
void main()
{

key();
char str[10];
Q=InitLQue();
top1=Init();
top2=Init();
Q=InitLQue();
int i;
int weather_1;
weather_1= weather();

while(i!=6)
{
system("CLS");
printf("\n");
if( weather_1 == 0)
printf("天气:晴朗");
else printf("天气:恶劣");
printf("\t\t\t停车场管理系统\n");
printf("\t\t\t_________-------------------_________\n");
printf("\t\t\t||\n");
printf("\t\t\t|1. 车辆进入停车场|\n");
printf("\t\t\t|2. 车辆离开停车场|\n");
printf("\t\t\t|3. 查看停车场内车辆信息|\n");
printf("\t\t\t|4. 查看便道上等待的车辆信息|\n");
printf("\t\t\t|5. 预约|\n");
printf("\t\t\t|6. 退出|\n");
printf("\t\t\t_____________________________________\n\n\n");
printf("请选择功能号 1 - 5:");
scanf("%d", &i);
switch(i)
{
case 1:
system("CLS");
top1 = into(top1,Q);
Sleep(2000);
break;
case 2:
system("CLS");
printf("请输入离开车辆的车牌号：");
scanf("%s", str);
top1=leave(top1, str, Q,weather_1);
Sleep(2000);
break;
case 3:
show(top1);
Sleep(2000);
break;
case 4:
T_shou(Q);
Sleep(2000);
break;
case 5:
top3=top1 = booking(top1);
Sleep(1000);
break;
case 6:
exit(1);
default:
printf("输入错误，请重新输入1—6:");
break;
}

}
}
stacknode *booking(stacknode *top1)//预约
{
stacknode *p,*q;
printf(" 请输入预约车辆的车牌号:");
p = (stacknode *)malloc(sizeof(stacknode));
scanf("%s", p->data.num);
q = top1;
while(q!= NULL)
{
if(strcmp(p->data.num, q->data.num) == 0)
{
printf("车牌号输入有误，该车已进入!");
return top1;
}
q = q->next;
if(top1 == NULL)
{
p->next = NULL;
top3=top1 = p;
}
else
{
p->next = top1;
top1 = p;
}
}
return top1;
}


//初始化
stacknode *Init()
{
stacknode *top;
top = (stacknode *)malloc(sizeof(stacknode));
top = NULL;
return top;
}

//初始化车辆进入
stacknode *into(stacknode *top1,LQueue *Q)
{
printf("%s",top3->data.num);
stacknode *p, *q;
time_t rawtime; //调用系统时间函数
struct tm *timeinfo; //时间结点
time( &rawtime);
timeinfo = localtime( &rawtime);
p = (stacknode *)malloc(sizeof(stacknode));
if(p == NULL)
{
printf(" 内存分配失败");
return top1;
}
printf(" 请输入进入停车场车辆的车牌号:");
scanf("%s", p->data.num);
q = top1;
while(q!= NULL)
{
if(strcmp(top3->data.num, p->data.num) == 0)
{
top3->data.time.day= timeinfo->tm_mday;
top3->data.time.hour = timeinfo->tm_hour;
top3->data.time.min= timeinfo->tm_min;
top3->data.time.sec= timeinfo->tm_sec;
top3->data.n = b;
}

if(strcmp(p->data.num, q->data.num) == 0)
{
printf("车牌号输入有误，该车已进入!");
return top1;
}
q = q->next;
}
p->data.time.day= timeinfo->tm_mday;
p->data.time.hour = timeinfo->tm_hour;
p->data.time.min= timeinfo->tm_min;
p->data.time.sec= timeinfo->tm_sec;
p->data.n = b;
if(b > maxs)
{
printf("停车场已满,请在便道等候!\n");
wait(Q,p);
return top1;
}
if(top1 == NULL)
{
p->next = NULL;
top1 = p;
}
else
{
p->next = top1;
top1 = p;
}
b++;
printf("车辆进入停车场成功，时间已经自动载入!\n");
printf("车牌为%s的汽车驶入时间为:%d号%d点%d分%d秒\n",top1->data.num,top1->data.time.day,top1->data.time.hour,top1->data.time.min,top1->data.time.sec);
return top1;
}
int weather()//通过随机种子判断天气情况
{
int wea;
srand(time(0));
wea = rand()%2;
return wea;
}

//停车费用计算函数
int expenses(stacknode *p, int x1, int x2, int x3, int x4)
{
int w;
if(x3!= 0)
if(weather()==0)
w = (x1*24+x2+1-(p->data.time.day*24+p->data.time.hour))*prices; //天气不同，价格不同
else
w = (x1*24+x2+1-(p->data.time.day*24+p->data.time.hour))*price;

else
if(weather()==0)
w = (x1*24+x2+1-(p->data.time.day*24+p->data.time.hour))*prices;
else
w = (x1*24+x2+1-(p->data.time.day*24+p->data.time.hour))*price;
return w;
}

//车辆停留时间
double time(stacknode *p,int x1,int x2,int x3,int x4)
{
double t1 = 0, t2 = 0, t3 = 0, t4 = 0;
if(x1 - (p->data.time.day == 0))
{
if(x2 - (p->data.time.hour == 0))
{
if( x3 - (p->data.time.min) == 0)
{
t4 = ( x4 - (p->data.time.sec)) / 3600.0;
}
else
{
t3 = (x3 - (p->data.time.min)) / 60.0;
}
}
else
{
t2 = (x2 - (p->data.time.hour));
}
}
else
{
t1 = ( x1 - (p->data.time.day)) * 24.0;
}
return t1 + t2 + t3 + t4;
}

//车辆离开函数
stacknode *leave(stacknode *top1, char str[], LQueue *Q,int weather_1)
{
int i, day, hour, min, sec;
time_t rawtime;
struct tm *timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
day= timeinfo->tm_mday;
hour = timeinfo->tm_hour;
min= timeinfo->tm_min;
sec= timeinfo->tm_sec;
stacknode *p, *q;

if(top1 == NULL)
{
printf("停车场没有车辆!\n");
return top1;
}
q = (stacknode *)malloc(sizeof(stacknode));
if(p == NULL)
{
printf("内存分配失败");
return top1;
}
q = top1;
while(q!= NULL)
{
if(strcmp(q->data.num,str) == 0)
break;
q = q->next;
}

{
printf("输入有误，该车辆不在停车场!\n");
if(q == NULL)
return top1;
}

for(i = top1->data.n; i > q->data.n; i--)
{
p = (stacknode *)malloc(sizeof(stacknode));
if(p == NULL)
{
printf("内存分配失败");
return top1;
}
strcpy(p->data.num,top1->data.num);
p->data.time = top1->data.time;
p->data.n= top1->data.n-1;
top1 = top1->next;
if(top2 == NULL)
{
p->next = NULL;
top2 = p;
}
else
{
p->next = top2;
top2 = p;
}
}

top1 = top1->next;

while( top2!= NULL)
{
p = (stacknode *)malloc(sizeof(stacknode)); if(p==NULL){printf("内存分配失败"); return top1; }
p->data.n = top2->data.n;
strcpy(p->data.num,top2->data.num);
p->data.time = top2->data.time;
p->next = top1;
top1 = p;
top2 = top2->next;
}

if(EmptyLQue(Q))
{
p = out(Q);
p->data.n--;
top1 = LQinto(p,top1);
}
else
b--;
printf("车牌为%s的汽车驶出时间为:%d号%d点%d分%d秒\n",q->data.num,day,hour,min,sec);
printf("汽车停留的时间为%f小时\n",time(q,day,hour,min,sec));
printf("车辆驶出停车场需要缴纳的费用为:%d元\n",expenses(q,day,hour,min,sec));
if(weather_1!=0)
{
printf("天气恶劣，请注意行车安全！");
}


return top1;
}

//队列函数初始化
LQueue *InitLQue()
{
LQueue *Q;
stacknode *p;
Q = (LQueue *)malloc(sizeof(LQueue));
p = (stacknode *)malloc(sizeof(stacknode));
p -> next=NULL;
Q -> front=Q->rear=p;
return Q;
}

//便道队列入队
LQueue *wait(LQueue *q, stacknode *s)
{
if(vip(s) == 1)
{
s->next = q->front->next;
q->front->next = s;
}
else
{
s->next = NULL;
q->rear->next = s;
q->rear = s;
}
return q;

}

//判断便道有无车辆等待
int EmptyLQue(LQueue *q)
{
if(q->front == q->rear)
return 0;
else
return 1;
}

//便道车辆出队
stacknode *out(LQueue *q)
{
stacknode *p;
p = q->front->next;
if(q->front->next == q->rear)
{
q->rear = q->front;
return p;
}
else
q->front->next = p->next;
p->next = NULL;
return p;
}

//便道队列进入停车场
stacknode *LQinto(stacknode *p, stacknode *top1)
{
p->next = top1;
top1 = p;
return top1;
}

//查看停车场内车辆信息
void show(stacknode *top1)
{
printf("停车场内全部车辆信息表\n");
if(top1 == NULL)
printf("停车场内无车!\n");

else
{
printf("车牌号进入时间位置\n");
while(top1!= NULL)
{
printf(" %s%d号%d点%d分第%d位\n",top1->data.num,top1->data.time.day,top1->data.time.hour,top1->data.time.min,top1->data.n);
top1 = top1->next;
}
}

}

//查看便道的汽车信息
void T_shou(LQueue *Q)
{
LQueue *q;
q = (LQueue *)malloc(sizeof(LQueue));
q ->front = Q->front;
q ->rear= Q->rear;
printf("候车区信息\n");
if(q->front == q->rear)
printf("候车区没有车辆!\n");
else
{
q->front = q->front->next;
printf("车牌号进入时间\n");
while(q->front!= NULL)
{
printf("%s%d号%d点%d分 \n",q->front->data.num,q->front->data.time.day,q->front->data.time.hour,q->front->data.time.min);
q->front = q->front->next;
}
}

}

int vip(stacknode *s)
{
char vip[10] = "123";
if(strcmp(s->data.num,vip) == 0)
return 1;
else
return 0;

}
void key()
{
int j=0;
int key_1,key_2=123;
printf("请输入管理员密码：");
while(1)
{

scanf("%d", &key_1);
if(key_1 == key_2)break;
if(j >= 3)
exit(0);
j++;
printf("输入错误，请从新输入:");
}
}



【数据结构 停车场管理系统（附源码）C++ 团队接课设、毕设 zhao835231559@126.com】

    推荐阅读


    上一篇：Vue.js学习-下载、安装、环境搭建

    下一篇：tomcat遇到的问题（一）Error instantiating servlet class[已解决]