数据结构电梯模拟.docx
《数据结构电梯模拟.docx》由会员分享,可在线阅读,更多相关《数据结构电梯模拟.docx(24页珍藏版)》请在冰豆网上搜索。
![数据结构电梯模拟.docx](https://file1.bdocx.com/fileroot1/2023-1/5/bf8989a4-9ffc-4488-a24b-3716723091c9/bf8989a4-9ffc-4488-a24b-3716723091c91.gif)
数据结构电梯模拟
一、【实验目的】3
二、【问题描述】3
三、【基本要求】3
四、【实验环境】3
五、【测试数据及其结果】4
六、【实验源代码】8
一、【实验目的】
帮助学生熟练掌握线性表的基本操作在链表结构中的实现,熟练进行各种链
表的操作和应用。
二、【问题描述】
设计一个电梯模拟系统。
这是一个离散的模拟程序,因为电梯系统是乘客和
电梯等“活动体”够成的集合,虽然他们彼此交互作用,但是他们的行为是基本独立的。
在离散的模拟中,一模拟时钟决定每个活动体的动作发生的时刻和顺序,系统在某个模拟瞬间处理有待完成的各种事情,然后把模拟时钟推进到某个动作预定要发生的下一个时刻。
三、【基本要求】
(1)、模拟某校五层教学楼的电梯系统。
该楼有一个自动电梯,能在每层停留。
五
个楼层由下至上依次称为地下层、第一层、第二层、第三层和第四层,其中第一层是大楼的进出层,即是电梯的“本垒层”,电梯“空闲”时,将来该层候命。
五个楼层从下到上的编号为:
0、1、2、3、4。
除了地下层外,每一层都有一个要求向下的按钮除了第四层外,每一层都有一个要求向上的按钮。
对应的变量为:
CallUp[0..3]和CallDown[1..4]。
电梯内的五个目标层按钮对应的变量为:
CallCar[0..4]。
(2)、电梯一共有七个状态,即正在开门(Opening)、已开门(Opene©、正在关门(Closing)、已关门(Closed)、等待(Waiting)、移动(Moving)、减速
(Decelerate)。
(3)、乘客可随机地进出于任何层。
对每个人来说,他有一个能容忍的最长等待时间,一旦等候电梯时间过长,他将放弃。
对于在楼层内等待电梯的乘客,将插入在等候队列里,每一层有两个等候队列,一队要求向上,一队要求向下,用链队列来实现。
对于在电梯内的乘客,用五个乘客栈来实现,该乘客要去哪一层,就把他放在相应编号的栈中,对应变量为EleStack[O,4]。
(4)、模拟时钟从0开始,时间单位为0.1秒。
人和电梯的各种动作均要耗费一定的时间单位(简记为t):
有人进出时,电梯每隔40t测试一次,若无人进出,则关门
关门和开门各需要20t
每个人进出电梯均需要25t
电梯加速需要15t
如果电梯在某层静止时间超过300t,则驶回1层候命。
(5)、按时序显示系统状态的变化过程:
发生的全部人和电梯的动作序列
四、【实验环境】
Windows7,VC++6.0
五、【测试数据及其结果】
1、乘客类型
反映乘客的所有属性。
ADTClient
数据对象:
D={ai€乘客信息,1=1,2,,,n,n》0}
数据关系:
R={|ai-1,ai€D,i=2,,,n}
基本操作:
PrintClientInfo(Clientconst&e,ClientStatus)
操作结果:
输出乘客信息。
CreatClient(Client*&p)
操作结果:
生成新的乘客。
DestoryClient(Client*&p)
操作结果:
该乘客离开系统。
GoAbove(Clientconst&e)
操作结果:
判断该乘客是否去往高层。
CInfloor(Clientconst&e)
操作结果:
返回乘客进入的楼层。
CInTime(Clientconst&e)
操作结果:
返回乘客进入时间。
COutfloor(Clientconst&e)
操作结果:
返回乘客进入时间。
}
2、乘客栈类型
电梯内的乘客用乘客栈表示,去不同楼层的乘客放在不同的栈中
ADTEstack
数据对象:
D={ai€乘客信息,1=1,2,,,n,n>0}
数据关系:
R={|ai-1,ai€D,i=2,,,n}
基本操作:
略。
}
3、等候队列类型
在电梯外等待的乘客用等待队列表示。
每层各有两个等待队列,分别为上楼队列和下楼队列。
与一般队列不同的是在基本操作中加入了放弃操作CGiveUp(WQueue
&Q,intfloor)。
4、电梯类型
表示电梯的各个属性和所有动作。
ADTElevator
数据对象:
D={ai€电梯信息,1=1,2,,,n,n>0}
基本操作:
InitEle(Elevator&E)
操作结果:
初始化电梯类型。
DestoryEle(Elevator&E)
操作结果:
销毁电梯类型。
EleDecide(Elevator&E,WQueuew[Maxfloor+1][2])
操作结果:
电梯动作决策。
ElevatorRun(Elevator&E,WQueuew[Maxfloor+1][2]){
操作结果:
电梯状态转换。
CountOver(Elevator&E)
操作结果:
判断电梯计时是否完成。
EleFloor(Elevatorconst&E)
操作结果:
返回电梯所在的层。
EleStatus(Elevatorconst&E)
操作结果:
返回电梯状态。
RequireAbove(Elevatorconst&E)
操作结果:
判断是否有高层请求。
RequireBelow(Elevatorconst&E)
操作结果:
判断是否有低层请求。
EleAchieved(Elevator&E)
操作结果:
判断电梯是否要停于当前层。
EleOpenDoor(Elevator&E)
操作结果:
判断电梯是否要开门。
}
5、高楼模块
实现电梯和乘客之间的互交功能。
包括:
InOut(Elevator&E,WQueuew[Maxfloor+1][2])
操作结果:
进行乘客的进出电梯活动。
NewClient(Elevator&E,WQueuew[5][2])
操作结果:
进入新乘客。
PrintStatus(Elevator&E,WQueuew[5][2])
操作结果:
输出当前状态。
Print(Elevator&E,Actiona)
操作结果:
输出电梯动作信息。
六、【实验源代码】
#include
#inelude
#include
#include
#inelude
#ineludevconio.h>
#include
//所有常量,全局变量和类型定义
#defineNULL0
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
安庆师范学院2012计算机卓越班
8/20
#defineOVERFLOW-2
#defineINT_MAX32767
typedefintStatus;//Status是函数类型,其值是函数结果状态代码
#defineEmpty0
//电梯状态
enumEleStatus{Opening,Opened,Closing,Closed,Moving,Decelerate,Waiting};
enumAction{DoorOpened,DoorClosed,GoingUp,GoingDown,Achieved,None};
enumEleStage{Up,Down,OpenDoor,Stop};
enumClientStatus{New,GiveUp,ln,Out,Finish};
300//电梯停候超时时间
#defineCloseTest
#defineOverTime
#defineDoorTime20
#defineInOutTime25
#defineMaxfloor4
#defineMinfloor0
longTime=0;
longMaxTime;
intInOutCount=0;
intInterTime=0;
intID=0;
intGiveUpNumber=O;
intTotalTime=0;
40//电梯关门测试时间//开门关门时间
//进岀电梯时间
//最高层
//最低层
//时钟
//系统运行最长时间
//用于进岀计时
//下一乘客进入系统的时间
//乘客编号
//乘客放弃的数目
//总共等待时间
//乘客类型
typedefstruct{
intClinetID;//乘客编号
intOutfloor;//去哪层
intInTime;//该乘客进入时间
intGivepuTime;//所能容忍的等待时间
intInfloor;//乘客进入的楼层
}Client;
//乘客类型基本操作
voidPrintClientlnfo(Clientconst&e,ClientStatuss){
switch(s){
caseNew:
printf("\t%d号乘客进入第%层.\n",e.ClinetID,e.Infloor);break;
caseGiveUp:
printf("\t%d号乘客放弃等待.\n",e.ClinetID);break;
caseOut:
printf("\t%d号乘客走岀电梯.\n",e.ClinetID);break;
caseIn:
printf("\t%d号乘客走进电梯,要去第%(层.\n",e.ClinetlD,e.Outfloor);break;
default:
break;
};
}
StatusCreatClient(Client*&p)
{
intd;
p=newClient;
if(!
p)returnOVERFLOW;
p->ClinetlD=++ID;
printf("%d所能容忍的等待时间:
",ID);seanf("%d",&d);
p->GivepuTime=d;
p->lnTime=Time;
printf(”下一乘客要到达的时间:
");
seanf("%d",&d);
InterTime=d;
printf(”所要到达的楼层:
");
seanf("%d",&d);
p->Outfloor=d;
while((p->lnfloor=rand()%(Maxfloor+1))==p->Outfloor);
PrintClientlnfo(*p,New);
returnOK;
}
StatusDestoryClient(Client*&p)
{
deletep;
p=NULL;
returnOK;
}
StatusGoAbove(Clientconst&e)
{
if(e.Outfloor>e.lnfloor)returnTRUE;
elsereturnFALSE;
}
StatusClnfloor(Clienteonst&e)
{
returne.lnfloor;
}
StatusClnTime(Clientconst&e)
{
returne.lnTime;
}
StatusCOutfloor(Clientconst&e)
{
returne.Outfloor;
#defineSTACK_INIT_SIZE100//存储空间初始分配量#defineSTACKINCREMENT50//存储空间分配增量
//乘客栈
*SElemType;
*base;
*top;stacksize;
typedefClient
typedefstruct{
SElemType
SElemTypeint
}ClientStack;
StatusInitStack(ClientStack&S)
{
S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!
S.base)returnOVERFLOW;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
returnOK;
}
StatusDestroyStack(ClientStack&S)
{
SElemType*p;
if(S.base)
{
for(p=S.base;pDestoryClient(*p);
free(S.base);
}
returnOK;
}
StatusClearStack(ClientStack&S)
{
if(!
S.base)returnERROR;
S.top=S.base;
returnOK;
}
StatusStackEmpty(ClientStackS)
{
if(S.top==S.base)returnTRUE;
elsereturnFALSE;
}
StatusStackLength(ClientStackS)
{
returnS.top-S.base;
}
StatusGetTop(ClientStackS,SElemType&e)
{
if(!
S.base)returnERROR;
e=*(S.top-1);
returnOK;
}
StatusPush(ClientStack&S,SElemTypee)
{
if(!
S.base)returnERROR;
if(S.top-S.base>=S.stacksize){
S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));if(!
S.base)returnOVERFLOW;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
returnOK;
}
StatusPop(ClientStack&S,SElemType&e)
{
if(S.top==S.base)returnERROR;
e=*(--S.top);
returnOK;
}
voidPrintStack(ClientStack&S)
{
SElemType*i;
i=S.base;
while(icout<<(*i++)->ClinetIDvv'';
}
//电梯类型
typedefstruct{
intfloor;//电梯所在层
intClientNumber;//电梯内人数
EleStatusstatus;//电梯当前状态
EleStageStage;//电梯运行时期
intCount;//用于电梯计时
intCallUp[Maxfloor+1];//每层的U|:
按钮
intCallDown[Maxfloo叶1];//每层的Down按钮
intCallCar[Maxfloo叶1];//电梯内的目标层按钮
ClientStackS[Maxfloo叶1];//乘客栈,要去不同楼层的人放在不同的栈中
}Elevator;
//电梯类型基本操作
voidInitEle(Elevator&E)
{
inti;
E.floor=1;
E.status=Waiting;E.Count=OverTime;
E.Stage=Down;
E.ClientNumber=O;
for(i=O;i<=Maxfloor;i++)
{
E.CallUp[i]=O;E.CallDown[i]=0;E.CallCar[i]=0;
}
for(i=0;i<=Maxfloor;i++)InitStack(E.S[i]);
}
StatusCountOver(Elevator&E)
{
if(E.Count){
E.Count--;returnFALSE;
}
returnTRUE;
}
voidDestoryEle(Elevator&E)
{
inti;
for(i=0;i<=Maxfloor;i++)DestroyStack(E.S[i]);
}
StatusEleFloor(Elevatorconst&E)
{
returnE.floor;
}
EleStatusEleStatus(Elevatorconst&E)
{
returnE.status;
}
StatusRequireAbove(Elevatorconst&E)
{
for(inti=E.floor+1;i<=Maxfloor;i++)
if(E.CallCar[i]||E.CallDown[i]||E.CallUp[i])returnTRUE;
returnFALSE;
}
StatusRequireBelow(Elevatorconst&E)
{
for(inti=E.floor-1;i>=Minfloor;i--)
if(E.CallCar[i]||E.CallDown[i]||E.CallUp[i])returnTRUE;
returnFALSE;
}
StatusEleAchieved(Elevator&E)
{
if(E.CallCar[E.floor])returnTRUE;
if(E.Stage==Up&&E.CallUp[E.floor]||E.Stage==Down&&E.CallDown[E.floor])returnTRUE;
if(E.Stage==Up&&E.CallDown[E.floor]&&!
RequireAbove(E))
{
E.Stage=Down;returnTRUE;
}
if(E.Stage==Down&&E.CallUp[E.floor]&&!
RequireBelow(E))
{
E.Stage=Up;returnTRUE;
}
returnFALSE;
}
StatusEleOpenDoor(Elevator&E)
{
if(E.CallCar[E.floor]||E.CallDown[E.floor]&&E.Stage==Down||E.CallUp[E.floor]&&E.Stage==Up)returnTRUE;
if(E.status==Waiting){
if(E.CallDown[E.floor]){E.Stage=Down;returnTRUE;}
if(E.CallUp[E.floor]){E.Stage=Up;returnTRUE;}
}
returnFALSE;
}
EleStageEleDecide(Elevator&E)
{
intAbove,Below;
Above=RequireAbove(E);
Below=RequireBelow(E);
if(Above==0&&Below==0)returnStop;
else{
if(E.Stage==Up){
if(Above!
=0)returnUp;
else{
E.Stage=Down;returnDown;
}
}
else{
if(Below!
=0)returnDown;
else{
E.Stage=Up;returnUp;
}
}
}
}
ActionElevatorRun(Elevator&E)
{
switch(E.status)
{
caseOpening:
E.status=Opened;E.Count=CloseTest;
returnDoorOpened;
caseOpened:
if(E.Stage==Down&&!
E.CallCar[E.floor]&&!
E.CallDown[E.floor]||E.Stage==Up&&!
E.CallCar[E.floor]&&!
E.CallUp[E.floor])
{E.status=Closing;E.Count=DoorTime;}break;
caseClosing:
E.status=Closed;
returnDoorClosed;
caseWaiting:
if(E.Count==0){
if(E.floor!
=1)E.CallCar[1]=1;
}
elseE.Count--;
if(EleOpenDoor(E)){
E.status=Opening;E.Count=DoorTime;break;
}
caseClosed:
break;
caseMoving:
//完成移动
if(E.Stage==Up)E.floo叶+;
elseE.floor--;
returnAchieved;
E.status=Opening;E.Count=DoorTime;
break;
};
returnNone;
}
//单链队列--队列的链式存储结构
typedefClient*QEIemType;
//等候队列
typedefstructQNode{
QEIemTypedata;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct{
QueuePtrfront;
QueuePtrrear;
}WQueue;
//等待队列的基本操作
StatusInitQueue(WQueue&Q)
{
Q.front=Q.rear=newQNode;
if(!
Q.front)returnOVERFLOW;
Q.front->next=NULL;
Q.front->data=NULL;
returnOK;
}
StatusDestroyQueue(WQueue&Q)
{
while(Q.front)
{
Q.rear=Q.front->next;
if(Q.front->data)DestoryClient(Q.front->data);
elseQ.front;
Q.front=Q.rear;
}returnOK;
}
StatusEnQueue(WQueue&Q,QElemTypee)
{
QueuePtr