数据结构上机停车场管理问题.docx
《数据结构上机停车场管理问题.docx》由会员分享,可在线阅读,更多相关《数据结构上机停车场管理问题.docx(18页珍藏版)》请在冰豆网上搜索。
数据结构上机停车场管理问题
实习指导
[实习题目]:
停车场管理。
[实习内容]:
首先,实现栈和队列的基本操作,在此基础上,实现停车场管理。
停车场管理问题描述:
设停车场是一个可停放n辆车的狭长通道,且只有一个大门可供汽车进出。
在停车场内,汽车按到达的先后次序,由北向南依次排列(假设大门在最南端)。
若车场内已停满n辆车,则后来的汽车需在门外的便道上等候,当有车开走时,便道上的第一辆车即可开入。
当停车场内某辆车要离开时,在它之后进入的车辆必须先退出车场为它让路,待该辆车开出大门后,其它车辆再按原次序返回车场。
每辆车离开停车场时,应按其停留时间的长短交费(在便道上停留的时间不收费)。
试编写程序,模拟上述管理过程。
要求以顺序栈模拟停车场,以链队列模拟便道。
从终端读入汽车到达或离去的数据,每组数据包括三项:
1是“到达”还是“离去”;
2汽车牌照;
3“到达”或“离去”的时刻。
与每组输入信息相应的输出信息为:
如果是到达的车辆,则输出其在停车场中或便道上的位置;
如果是离去的车辆,则输出其在停车场中停留的时间和应交的费用。
(提示:
需另设一个栈,临时停放为让路而从车场退出的车。
)
[实习目的]:
通过实习,熟悉栈和队列的基本特点,掌握利用栈和队列解决具体问题的方法。
[实习步骤]:
1.实现顺序栈的基本操作
●基本思路
首先实现一个整型顺序栈的初始化、判栈空、进栈、出栈等基本操作,并在主程序中调用这些操作。
●基本框架
#include
#defineTRUE1
#defineFALSE0
#defineStack_Size50
typedefintStackElementType;
typedefstruct
{
StackElementTypeelem[Stack_Size];
inttop;
}SeqStack;
/*以下是函数原形说明。
注意函数头后面有分号。
*/
voidInitStack(SeqStack*s);
intIsEmpty(SeqStack*s);
intPush(SeqStack*s,StackElementTypee);
intPop(SeqStack*s,StackElementType*e);
/*以下是函数定义。
注意函数头后面无分号。
*/
voidInitStack(SeqStack*s)
/*顺序栈的初始化函数*/
{……;}
intIsEmpty(SeqStack*s)
/*顺序栈的判栈空函数*/
{……;}
intPush(SeqStack*s,StackElementTypee)
/*顺序栈的进栈函数*/
{……;}
StatusPop(SeqStack*s,StackElementType*e)
/*顺序栈的出栈函数*/
{……;}
voidmain(void)
{……;}
●要点提示
主程序的基本过程如下:
voidmain(void)
{SeqStackmy_stack;
StackElementTypex;
StackElementTypey;
InitStack(&my_stack);
if(IsEmpty(&my_stack))打印:
“my_stack已被初始化为空栈”;
提示输入10个正整数;
循环10次,执行下面操作:
{
读入整数x;
Push(&my_stack,x);
}
while(!
IsEmpty(&my_stack))
{
Pop(&my_stack,&y);
打印y;
}
}
●测试数据
读入数据:
19,14,23,01,68,20,84,27,55,11
打印结果:
读入序列的逆序。
2.同时实现顺序栈和链队列的基本操作
●基本思路
在前面已经实现的整型顺序栈的基础上,进一步实现一个整型链队列的基本操作。
●基本框架
(1)在上述程序框架的前面,增加如下包含语句:
#include
(2)在上述程序框架的类型定义部分,增加如下链队列定义:
typedefintQueueElementType;
typedefstructNode
{
QueueElementTypedata;/*数据域*/
structNode*next;/*指针域*/
}LinkQueueNode;
typedefstruct
{
LinkQueueNode*front;
LinkQueueNode*rear;
}LinkQueue;
(3)在上述程序框架的函数原型说明部分,增加如下链队列的操作函数原型说明:
intInitQueue(LinkQueue*Q);
intEmptyQueue(LinkQueueQ);
intEnterQueue(LinkQueue*Q,QueueElementTypex);
intDeleteQueue(LinkQueue*Q,QueueElementType*x);
(4)在上述程序框架的函数定义部分,增加上述链队列的操作函数定义。
(5)在上述程序框架的主程序中,增加调用链队列操作函数的有关语句。
●要点提示
主程序的基本过程如下:
voidmain(void)
{SeqStackmy_stack;
LinkQueuemy_queue;
intx;
InitStack(&my_stack);
InitQueue(&my_queue);
if(IsEmpty(&my_stack))打印:
“栈为空”;
提示输入10个正整数;
循环10次,执行下面操作:
{
读入整数x;
Push(&my_stack,x);
}
while(!
IsEmpty(&my_stack))
{
Pop(&my_stack,&x);
将x加入队列my_queue;
}
while(队列my_queue非空)
{
删除my_queue的队首元素,并送给x;
打印x;
}
}
注意指针参数的调用方法。
●测试数据
读入数据:
19,14,23,01,68,20,84,27,55,11
打印结果:
读入序列的逆序。
3.实现停车场管理问题
●基本思路
停车场管理问题可以用如下简图说明:
将“车库”和“暂时退车道”定义为两个栈,将“便道”定义为一个队列。
在前面程序的基础上,进行如下修改:
(1)定义一个表示“车辆信息”的结构体类型。
(2)将栈元素类型和队列元素类型均改为“车辆信息”结构体指针类型(或“车辆信息”结构体类型),并相应修改有关函数。
(3)定义一个“车辆到达处理”函数和“车辆离开处理”函数。
●基本框架
(1)在上述程序框架的类型定义部分,增加一个表示“车辆信息”的结构体类型定义,设置两个数据域:
牌照、到达时刻。
牌照用字符串表示,到达时刻可先用正整数表示(参后面测试数据)。
(2)在上述程序框架的函数原型说明部分,增加“车辆到达处理”函数和“车辆离开处理”函数的原型说明。
(3)在上述程序框架的函数定义部分,增加“车辆到达处理”函数和“车辆离开处理”函数的函数定义。
(4)为了简化参数传递,可以先将有关的栈和队列定义为全局变量,调通后再改为用参数传递。
●要点提示
主程序的基本过程如下:
voidmain(void)
{
重复如下过程,直到读入结束标志:
{
提示输入一辆车的信息(到达/离开,牌照,当前时刻);
读入这辆车的信息;
如果是到达车辆,则调用“车辆到达处理”函数;
否则调用“车辆离开处理”函数。
}
}
“车辆离开处理”函数的基本过程如下:
voidleave(牌照,离开时刻)
{
当“车库”栈不空,并且栈顶车辆不是要离开的车时,重复下面操作:
{
将“车库”栈的栈顶车辆退出;
让退出的车辆进入“暂时退车道”栈;
}
如果找到要离开的车辆,则计算并输出停车费用;
将“暂时退车道”栈中的车辆倒回“车库”栈;
如果“便道”队列不空,则队头车辆出队,并进入“车库”栈;
}
注意将“出队车辆”的到达时刻改为“离开车辆”的离开时刻。
●测试数据
假设用0表示车辆离开,1表示车辆到达,-1表示程序结束;用字符串表示车辆的牌照;用正整数表示时刻,每单位时间的停车费用是5元;停车场大小n=2。
则运行结果如下:
输入数据:
1,A001,5
输出结果:
A001当前停放在车库1号位
输入数据:
1,B002,10
输出结果:
B002当前停放在车库2号位
输入数据:
0,A001,15
输出结果:
A001停放时间为10,停车费用为50元
输入数据:
1,C003,20
输出结果:
C003当前停放在车库2号位
输入数据:
1,D004,25
输出结果:
D004当前停放在便道1号位
输入数据:
1,E005,30
输出结果:
E005当前停放在便道2号位
输入数据:
0,B002,35
输出结果:
B002停放时间为25,停车费用为125元
便道上的D004进入车库,入库时刻为35,当前停放在车库2号位
输入数据:
0,D004,40
输出结果:
D004停放时间为5,停车费用为25元
便道上的E005进入车库,入库时刻为40,当前停放在车库2号位
输入数据:
-1,#000,0
输出结果:
当前车库中还有2辆车,便道上无车。
再见!
[改进建议]:
1.每次输出结果中,打印整个车库和整个便道的当前停车情况一览表。
2.将车库”栈、“暂时退车道”栈改为对顶栈,共享同一空间。
3.根据车辆类型,分别收费。
4.便道上的车可以直接开走,此时排在它前面的车要依次开出,并排到队尾。
5.停放在便道上的车也收费,但收费标准较低。
6.将时间改为时、分表示法。
7.到达时刻和离开时刻采用本机系统时间。
8.用随机数模拟车辆到达间隔和停车时间。
9.用动画演示运行过程。
源代码:
//parking.cpp:
Definestheentrypointfortheconsoleapplication.
#include
#include
#include"string.h"
#defineTRUE1
#defineFALSE0
#defineStack_Size2
/**************车辆信息******************/
typedefstructCar
{
charNumber[10];/*车牌号*/
inttime;/*到达时刻*/
}Car;
/******************车库栈定义**********************/
typedefstruct
{
Carelem[Stack_Size];
inttop;
}SeqStack;
/******************暂退车道栈定义**********************/
typedefstruct
{
Carelem2[Stack_Size];
inttop2;
}SeqStack2;
/*****************队列定义******************/
typedefstructNode
{
Cardata;/*数据域*/
structNode*next;/*指针域*/
}LinkQueueNode;
typedefstruct
{
LinkQueueNode*front;
LinkQueueNode*rear;
intlength;
}LinkQueue;
/*以下是函数原形说明。
注意函数头后面有分号。
*/
voidInitStack(SeqStack*s);
intIsEmpty(SeqStack*s);
intPush(SeqStack*s,Care);
intPop(SeqStack*s,Car*e);
intInitQueue(LinkQueue*Q);
intEmptyQueue(LinkQueueQ);
intEnterQueue(LinkQueue*Q,Carx);
intDeleteQueue(LinkQueue*Q,Car*x);
intCarArrive(SeqStack*s,LinkQueue*Q,charnum[],intarrivetime);
intCarLeave(SeqStack*s,LinkQueue*Q,SeqStack*s2,char[],intleavetime);
/**********以下是函数定义。
注意函数头后面无分号。
********/
voidInitStack(SeqStack*s)
/*顺序栈的初始化函数*/
{
s->top=-1;
}
intIsEmpty(SeqStack*s)
/*顺序栈的判栈空函数*/
{
if(s->top==-1)
return(TRUE);
else
return(FALSE);
}
intIsFull(SeqStack*s)
/*顺序栈的判栈满函数*/
{
if(s->top==Stack_Size)
return(TRUE);
else
return(FALSE);
}
intPush(SeqStack*s,Car*e)
/*顺序栈的进栈函数*/
{
if(s->top==Stack_Size-1)return(FALSE);
else
{
s->top++;
s->elem[s->top]=*e;
return(TRUE);
}
}
intPop(SeqStack*s,Car*e)
/*顺序栈的出栈函数*/
{
if(s->top==-1)
return(FALSE);
else
{
*e=s->elem[s->top];
s->top--;
return(TRUE);
}
}
intInitQueue(LinkQueue*Q)
/*链队列的初始化*/
{Q->length=0;
Q->front=(LinkQueueNode*)malloc(sizeof(LinkQueueNode));
if(Q->front!
=NULL)
{
Q->rear=Q->front;
Q->front->next=NULL;
return(TRUE);
}
else
return(FALSE);/*溢出*/
}
intEmptyQueue(LinkQueue*Q)
/*链队列的判空*/
{
if(Q->front==Q->rear)
return(TRUE);
else
return(FALSE);
}
intEnterQueue(LinkQueue*Q,Car*x)
/*链队列的入队操作,将数据元素x插入到队列中*/
{
LinkQueueNode*NewNode;
NewNode=(LinkQueueNode*)malloc(sizeof(LinkQueueNode));
if(NewNode!
=NULL)
{
NewNode->data=*x;
NewNode->next=NULL;
Q->rear->next=NewNode;
Q->rear=NewNode;
Q->length++;
return(TRUE);
}
else
return(FALSE);//溢出
}
intDeleteQueue(LinkQueue*Q,Car*x)
/*链队列的出队操作,对头出列,并存放到x所指的储存空间中*/
{
LinkQueueNode*p;
if(Q->front==Q->rear)
return(FALSE);
p=Q->front->next;
Q->front->next=p->next;/*对头元素p出列*/
if(Q->rear==p)/*如果对中只有一个元素p,则p出对后成为空队*/
Q->rear=Q->front;
*x=p->data;
free(p);/*释放存储空间*/
Q->length--;
return(TRUE);
}
/***********************车辆到达函数***************************************/
intCarArrive(SeqStack*s,LinkQueue*Q,charnum[],intarrivetime)
{
Car*e;
e=(Car*)malloc(sizeof(Car));
strcpy(e->Number,num);//到达车辆的车牌号
e->time=arrivetime;//到达车辆的时间
if(s->top{
Push(s,e);//车辆入栈
printf("-------------------------------------\n");
printf("车辆%s停在车库%d号位上\n",num,s->top+1);
}
else
{
EnterQueue(Q,e);/*若车库已满,就入队列*/
printf("-------------------------------------\n");
printf("车辆%s停在便道%d号位上\n",num,Q->length);
}
return0;
}
/***********************车辆离开函数*******************************************/
voidCarleave(SeqStack*s,LinkQueue*Q,charnum[],intleavetime)
{SeqStacks2;
InitStack(&s2);
Car*Acar;//要离开车辆
Acar=(Car*)malloc(sizeof(Car));
intmoney,parktime;
while(!
IsEmpty(s)&&(strcmp(s->elem[s->top].Number,num)))
//当"车库"栈不空,并且栈顶车辆不是要离开的车时,重复下面操作:
{
//将"车库"栈的栈顶车辆退出;
Pop(s,Acar);
//让退出的车辆进入"暂时退车道"栈;
Push(&s2,Acar);
}
//如果找到要离开的车辆,则计算并输出停车费用;
Pop(s,Acar);
parktime=leavetime-Acar->time;
money=5*parktime;
printf("-------------------------------------\n");
printf("%s的停车时间为%d,停车费用为%d\n",num,parktime,money);
//将"暂时退车道"栈中的车辆倒回"车库"栈;
while(!
IsEmpty(&s2))
{
Pop(&s2,Acar);
Push(s,Acar);
}
//如果"便道"队列不空,则队头车辆出队,并进入"车库"栈;
if(!
EmptyQueue(Q))
{
Car*Bcar;//出便道进车库的车
Bcar=(Car*)malloc(sizeof(Car));
DeleteQueue(Q,Bcar);
Bcar->time=leavetime;//将"出队车辆"的到达时刻改为"离开车辆"的离开时刻。
Push(s,Bcar);
printf("便道上的%s进入车库,入库时刻为%d,当前停放在车库%d号位\n",Bcar->Number,Bcar->time,s->top+1);
}
}
/***********************车库停车情况一览表函数*******************************************/
voidprintfstack(SeqStacks)
{
Car*Ccar;
Ccar=(Car*)malloc(sizeof(Car));
if(s.top==-1)
printf("车库无车\n");
else
{
while(s.top!
=-1)
{
*Ccar=s.elem[s.top];
s.top--;
printf("%s%d\n",Ccar->Number,Ccar->time);
}//endwhile
}//ENDELSE
}
/***********************便道停车情况一览表函数*******************************************/
intprintfQueen(LinkQueueQ)
{Car*Dcar;
Dcar=(Car*)malloc(sizeof(Car));
LinkQueueNode*p;
p=Q.front->next;
if(Q.front==Q.rear)
{printf("便道无车\n");
return(FALSE);
}
while(Q.front!
=Q.rear)
{
*Dcar=p->data;
if(Q.rear==p)/*如果对中只有一个元素p,则p出对后成为空队*/
Q.rear=Q.front;
printf("%s%d\n",Dcar->Number,Dcar->time);
p=p->next;
//free(p);/*释放存储空间*/
}
return(TRUE);
}
/***************************主函数**************************************************/
voidmain(void)
{
charch;
SeqStackmy_stack;
LinkQueuemy_queue;
InitStack(&my_stack);
InitQueue(&my_queue);
while
(1)
{intt;
printf("*************************************\n");
printf("WELETOPARK\n");
printf("***