数据结构电梯模拟.docx
《数据结构电梯模拟.docx》由会员分享，可在线阅读，更多相关《数据结构电梯模拟.docx（24页珍藏版）》请在冰豆网上搜索。
数据结构电梯模拟
一、【实验目的】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
升级会员 