OrderInsert（ev,et,cmp）;
i=Minimum（q）;
f.ArrivalTime=en.OccurTime;
f.Duration=durtime;
EnQueue（q[i],f）;
if（QueueLength（q[i]）==1）
{
et.OccurTime=en.OccurTime+durtime;
et.NType=i;
OrderInsert（ev,et,cmp）;//设定第i队列的一个离开事件并插入事件表
}
}
voidCustomerDeparture（）
{inti;
i=en.NType;
DeQueue（q[i],customer）;
TotalTime+=en.OccurTime-customer.ArrivalTime;
if（!
QueueEmpty（q[i]））
{GetHead（q[i],customer）;
et.OccurTime=en.OccurTime+customer.Duration;
et.NType=i;
OrderInsert（ev,et,cmp）;
}
}
voidBank_Simulation（）
{Linkp;
OpenForDay（）;//初始化
while（!
ListEmpty（ev））
{DelFirst（ev,GetHead（ev）,p）;
en.OccurTime=GetCurElem（p）.OccurTime;
en.NType=GetCurElem（p）.NType;
if（en.NType==Qu）
CustomerArrived（）;
else
CustomerDeparture（）;
}
printf（"顾客总数:
%d,所有顾客总共耗时%d分钟，平均每人耗时%d分钟\n",CustomerNum,TotalTime,TotalTime/CustomerNum）;
}
voidmain（）
{
printf（"请输入银行营业时间长度单位（单位：
分）\n"）;
scanf（"%d",&CloseTime）;
Bank_Simulation（）;
}
附：
Queue.h
#include
#include
#include
#include
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
typedefintstatus;
typedefintBoolean;
typedefstruct
{intArrivalTime;//时间发生时刻
intDuration;//事件类型
}QElemtype;
typedefstructQNode//单链队列
{QElemtypedata;
QNode*next;
}*QueuePtr;
structLinkQueue
{
QueuePtrfront,rear;//对头队尾指针
};
//和栈一样，队列也是操作受限的线性表，只允许在队尾插入元素,在队头删除元素
//为了便于插入元素，设立了队尾指针
statusInitQueue（LinkQueue&Q）
{if（!
（Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））））
exit（OVERFLOW）;
Q.front->next=NULL;
returnOK;
}
statusDestroyQueue（LinkQueue&Q）
{while（Q.front）
{Q.rear=Q.front->next;
free（Q.front）;
Q.front=Q.rear;
}
returnOK;
}
statusClearQueue（LinkQueue&Q）
{QueuePtrp,q;
Q.rear=Q.front;
p=Q.front->next;
Q.front->next=NULL;
while（p）
{q=p;
p=p->next;
free（q）;
}
returnOK;
}
statusQueueEmpty（LinkQueueQ）
{if（Q.front==Q.rear）
returnOK;
else
returnFALSE;
}
intQueueLength（LinkQueueQ）
{
inti=0;
QueuePtrp,q;
p=Q.front;
while（p!
=Q.rear）
{i++;
p=p->next;
}
returni;
}
statusGetHead（LinkQueueQ,QElemtype&e）\
{//若队列不空则用e返回Q的队头元素
if（Q.front==Q.rear）
returnERROR;
else
{e=Q.front->next->data;//这里的队头是Q.front->next->data哦
returnOK;
}
}
statusEnQueue（LinkQueue&Q,QElemtypee）
{//e入队列是插入队尾哦
QueuePtrp;
if（!
（p=（QueuePtr）malloc（sizeof（QNode））））
exit（OVERFLOW）;
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
returnOK;
}
statusDeQueue（LinkQueue&Q,QElemtype&e）
{//出队列，并用e返回其值
QueuePtrp;
if（Q.front==Q.rear）
returnERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if（p==Q.rear）
Q.rear=Q.front;//找回队尾指针
free（p）;
returnOK;
}
statusQueueTraverse（LinkQueueQ,void（*vi）（QElemtype））
{//队头到队尾遍历
QueuePtrp;
for（p=Q.front->next;p;p=p->next）
vi（p->data）;
printf（"\n"）;
returnOK;
}
voidvisit（QElemtypec）
{
printf（"%d",c）;
}
Shuxu.h
#include
#include
#include
#include
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
typedefintstatus;
typedefintBoolean;
typedefstruct
{intOccurTime;//时间发生时刻
intNType;//时间类型
}Event,Elemtype;
typedefstructLNode
{Elemtypedata;
LNode*next;
}*Link,*Position;
structLinkList
{Linkhead,tail;
intlen;
};
statusMakeNode（Link&p,Elemtypee）
{//分配由p指向的值为e的节点，并返回OK如果分配失败，则返回ERROR
p=（Link）malloc（sizeof（LNode））;
if（!
p）
returnERROR;
p->data=e;
returnOK;
}
statusFreeNode（Link&p）
{free（p）;
p=NULL;
returnOK;
}
statusInitList（LinkList&L）
{Linkp;
p=（Link）malloc（sizeof（LNode））;
if（p）
{
p->next=NULL;
L.head=L.tail=p;
L.len=0;
returnOK;
}
else
returnERROR;
}
statusClearList（LinkList&L）
{
Linkp,q;
if（L.head!
=L.tail）
{
q=p=L.head->next;
L.head->next=NULL;
while（p!
=L.tail）{
p=q->next;
free（q）;
q=p;
}
free（q）;
L.tail=L.head;
L.len=0;
}
returnOK;
}
statusDestroyList（LinkList&L）
{
ClearList（L）;
FreeNode（L.head）;
L.tail=NULL;
L.len=0;
returnOK;
}
statusInsFirst（LinkList&L,Linkh,Links）
{//h指向L的一个节点，把h当做头结点，将s所指的节点插入在第一个节点之前
s->next=h->next;
h->next=s;
if（h==L.tail）
L.tail=h->next;
L.len++;
returnOK;
}
statusDelFirst（LinkList&L,Linkh,Link&q）
{q=h->next;
if（q）//链表非空
{
h->next=q->next;
if（!
h->next）;
L.tail=h;//补上表尾指针
L.len--;
returnOK;
}
else
returnFALSE;
}
statusAppend（LinkList&L,Links）
{
//将指针s所指的一串结点链接在线性表L之后，并改变链表L的尾指针向新的尾结点
inti=1;
L.tail->next=s;
while（s->next）
{
s=s->next;
i++;
}
L.tail=s;
L.len+=i;
returnOK;
}
PositionPriorPos（LinkListL,Linkp）
{//已知p指向线性链表的一个结点，返回p所指结点的直接前驱的位置，若无前驱则返回NULL
Linkq=L.head->next;;
if（q==p）
returnNULL;
else
{
while（q->next!
=p）
q=q->next;
returnq;
}
}
statusRemove（LinkList&L,Link&q）
{//删除线性链表的表尾结点并以q返回，改变尾指针为新的表尾结点
Linkp=L.head;
if（!
L.head->next）
{q=NULL;
returnFALSE;
}
while（p->next!
=L.tail）
p=p->next;
q=L.tail;
p->next=NULL;
L.tail=p;
L.len--;
returnOK;
}
statusInsBefore（LinkList&L,Link&p,Links）
{//已知p指向线性表L中的一个结点，将s所指结点插入p所指结点之前，
//并修改指针p指向新插入的结点
Linkq;
q=PriorPos（L,p）;
if（!
q）
q=L.head;
s->next=p;
q->next=s;
p=s;
L.len++;
returnOK;
}
statusInsAfter（LinkList&L,Link&p,Links）
{//已知p指向线性表L中的一个结点，将s所指结点插入p所指结点之后，
//并修改指针p指向新插入的结点
if（p==L.tail）
L.tail=s;
s->next=p->next;
p->next=s;
p=s;
L.len++;
returnOK;
}
statusSetCurElem（Linkp,Elemtypee）
{//已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值
p->data=e;
returnOK;
}
ElemtypeGetCurElem（Linkp）
{
returnp->data;
}
statusListEmpty（LinkListL）
{
if（L.len）
returnFALSE;
else
returnTRUE;
}
intListLength（LinkListL）
{
returnL.len;
}
PositionGetHead（LinkListL）{
returnL.head;
}
PositionGetLast（LinkListL）
{
returnL.tail;
}
PositionNextPos（Linkp）
{
returnp->next;
}
statusLocatePos（LinkListL,inti,Link&p）
{intj;
if（i<0||i>L.len）
returnERROR;
else
{
p=L.head;
for（j=1;j<=i;j++）
p=p->next;
returnOK;
}
}
PositionLocateElem（LinkListL,Elemtypee,status（*compare）（Elemtype,Elemtype））
{Linkp=L.head;
do
p=p->next;
while（p&&!
（compare（p->data,e）））;
returnp;
}
statusListTraverse（LinkListL,void（*visit）（Elemtype））
{
Linkp=L.head->next;
intj;
for（j=1;j<=L.len;j++）
{
visit（p->data）;
p=p->next;
}
printf（"\n"）;
returnOK;
}
statusOrderInsert（LinkList&L,Elemtypee,int（*cmp）（Elemtype,Elemtype））
{//已知L为有序线性表将元素e按照非降序插入在L中
Linko,p,q;
q=L.head;
p=q->next;
while（p!
=NULL&&cmp（p->data,e）<0）
{
q=p;
p=p->next;
}
o=（Link）malloc（sizeof（LNode））;
o->data=e;
q->next=o;
o->next=p;
L.len++;
if（!
p）
L.tail=o;
returnOK;
}
statusLocateElem（LinkListL,Elemtypee,Position&q,int（*com）（Elemtype,Elemtype））
{//若升序链表L中存在与E满足判定函数com取值为0的元素则q指示L
//中第一个元素的值为e的结点位置，并返回TRUE否则q指示第一个与e满足判断函数
//compare（）取值>0的前驱的位置，并返回FALSE
Linkp=L.head,pp;
do
{pp=p;
p=p->next;
}while（p&&（com（p->data,e）<0））;
if（!
p||com（p->data,e）>0）
{q=pp;
returnFALSE;
}
else
{
q=p;
returnTRUE;
}
}
升级会员 