银行业务模拟程序

实验二银行业务模拟程序

一、实验目的

用Turbo C 语言设计实现一个用事件驱动的银行业务离散模型, 模拟每一个客户到达银行、排入人最少的业务窗口队列、排至窗口并处理完业务后离开的整个过程，统计客户在银行的平均逗留时间

二、实验环境

1、Windows7操作系统；

2、VisualC++.

三、实验内容

假设某银行有4个窗口对外接待客户，从早上银行开门起不断有客户进入银行。由于每个窗口在某时刻只能接待一个客户，因此在客户人数众多的时需在每个窗口前顺次排队，对于刚进入银行的客户，如果某个窗口的业务员正空闲，则可上前办理业务；反之，若4个窗口均有客户所占，他便会排在人数最少的队伍后面。现在需要编制一个程序一模拟银行的这种业务活动并计算一天中客户在银行的平均逗留时间。

假设每个客户办理业务的时间不超过30分钟；两个相邻到达银行的客户的时间间隔不超过5分钟。模拟程序从第一个客户到达时间为“0”开始起运行。

四、概要设计

1、存储结构的类型定义：

此模拟程序需要两种数据类型：有序链表和队列。它们的数据元素类型定义分别如下：（1）typedef struct

{int OccurTime; //事件发生时刻

int NType; //事件类型，Qu表示到达事件，0-Qu-1表示Qu个窗口的离开事件

}Event,ElemType;//事件类型，有序链表LinkList的数据元类型

typedef LinkList EventList; // 事件链表类型，定义为有序链表

（2）typedef struct

{int ArrivalTime;//到达时刻

int Duration;//办理业务所需时间

}QElemType; //队列的数据元素类型

2、单链表示意图：

如课本P69图所示。

3、项目组成图：

4、exp_yh.cpp的程序文件包含的函数原型及功能

int cmp(Event a,Event b){ }：依事件a的发生时刻<、=或>事件b的发生时刻分别返回-1、

0或1 ；

Status InitList(LinkList &L)：构造一个空的线性链表；

Status InitQueue(LinkQueue &Q):构造一个空的队列；

Status OrderInsert():已知L为有序线性链表，将元素e按非降序插入在L中；

void OpenForDay():初始化操作；

void Random():产生两个随机数，分别表示客户办理时间和两个相邻达到银行的客户的时

间间隔；

int QueueLength()：求队列的长度；

int Minimum() ：返回最短队列的序号

Status EnQueue():插入元素e为Q的新的队尾元素；

Status DeQueue():若队列不空，删除Q的对头元素，用e返回其值，并返回OK，否则返回ERROR

V oid CustomerArrived():处理客户到达事件；

Status GetHead():若队列不空，用e返回Q的对头元素，并返回OK，否则返回ERROR;

Position GetHead():返回线性链表L中头结点的位置；

Status QueueEmpty():若Q为空队列，则返回TRUE，否则返回FALSE；

void CustomerDeparture():处理客户离开事件

Status ListEmpty():若线性链表L为空表，则返回TRUE,否则返回FALSE；

Status DelFirst():h指向L的一个结点，把h当做头结点，删除链表中的第一个节点并以q返回，若链表为空，q=NULL,并返回FALSE;

ElemType GetCurElem():已知p指向线性链表中的一个结点，返回p所指节点中数据元素

的值；

void Bank_Simulation():打印出窗口，平均逗留时间

main():主函数

5、项目的模块结构及函数调用关系：

本程序包含5个模块：

（1）主程序模块：

void main()

{ 接受命令；

处理命令；}

（2）事件链表表单元模块——实现链表的抽象数据类型；

（3）队列单元模块——实现队列的抽象数据类型；

（4）事件结点结构单元模块——定义链表的结点结构；

（5）队列结点结构单元模块——定义队列的结点结构；

各模块之间的调用关系如下：主程序模块—〉链表、队列表单元模块—>队列、链表

结点结构单元模块。

五、详细设计

源代码清单见附录

六、测试，改进，界面

1、首先在编译是出现如下错误：经检查，程序中使用了Random()函数，但是相关的头

文件没有被包含进来，将“#include”补上则错误解决。

2、正常测试结果如下：

七、附录——源代码附件

#include "stdio.h"

#include "stdlib.h"

#include"math.h"

#define Qu 4 //客户队列数

#define Khjg 5 //两相邻到达的客户的时间间隔最大值

#define Blsj 30//每个客户办理业务的时间最大值

#define OK 1

#define ERROR 0

#define TRUE 1

#define FALSE 0

typedef int Status;

typedef int Boolean;

typedef struct

{

int OccurTime; //事件发生时刻

int NType; //事件类型，Qu表示到达事件，

//0-Qu-1表示Qu个窗口的离开事件

}Event,ElemType;//事件类型，有序链表LinkList的数据元类型

typedef struct LNode // 结点类型

{

ElemType data;

LNode *next;

}*Link,*Position;

struct LinkList // 链表类型

{

Link head,tail; // 分别指向线性链表中的头结点和最后一个结点

int len; // 指示线性链表中数据元素的个数

};

typedef LinkList EventList; // 事件链表类型，定义为有序链表typedef struct

{

int ArrivalTime;

int Duration;

}QElemType; //队列的数据元素类型

typedef struct QNode

{

QElemType data;

QNode *next;

}*QueuePtr; //队列

struct LinkQueue

{

QueuePtr front,rear; // 队头、队尾指针

};

EventList ev;//事件表

Event en; //事件

Event et;//临时变量

LinkQueue q[Qu]; //Qu个队列客户

QElemType customer; //客户记录

int TotalTime=0,CustomerNum=0;//累计客户逗留时间,客户数(初值为0) int CloseTime; // 银行营业时间(单位是分)

int cmp(Event a,Event b)

{ // 依事件a的发生时刻<、=或>事件b的发生时刻分别返回-1、0或1 if(a.OccurTime==b.OccurTime)

return 0;

else

return (a.OccurTime-b.OccurTime)/abs(a.OccurTime-b.OccurTime);

}

Status InitList(LinkList &L)

{ // 构造一个空的线性链表

Link p;

p=(Link)malloc(sizeof(LNode)); // 生成头结点

if(p)

{

p->next=NULL;

L.head=L.tail=p;

L.len=0;

return OK;

}

else

{ printf("分配内存失败!");

return ERROR;

}

}//InitList

Status InitQueue(LinkQueue &Q)

{ // 构造一个空队列Q

if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))

exit(-1);

Q.front->next=NULL;

return OK;

}//InitQueue

Status OrderInsert(LinkList &L,ElemType e,int (*comp)(ElemType,ElemType)) { // 已知L为有序线性链表，将元素e按非降序插入在L中。（用于一元多项式） Link o,p,q;

q=L.head;

p=q->next;

while(p!=NULL&&comp(p->data,e)<0) // p不是表尾且元素值小于e

{

q=p;

p=p->next;

}

o=(Link)malloc(sizeof(LNode)); // 生成结点

o->data=e; // 赋值

q->next=o; // 插入

o->next=p;

L.len++; // 表长加1

if(!p) // 插在表尾

L.tail=o; // 修改尾结点

return OK;

}//OrderInsert

void OpenForDay()

{

int i;

InitList(ev);

en.OccurTime=0;

en.NType=Qu;

OrderInsert(ev,en,cmp);//插入事件表

for(i=0;i

InitQueue(q[i]);

}//OpenForDay

void Random(int &d,int &i)

{

d=rand()%Blsj+1;//1到Blsj之间的随机数

i=rand()%Khjg+1;

}//Random

int QueueLength(LinkQueue Q)

{ // 求队列的长度

int i=0;

QueuePtr p;

p=Q.front;

while(Q.rear!=p)

{

i++;

p=p->next;

}

return i;

}//QueueLength

int Minimum(LinkQueue Q[]) //返回最短队列的序号{

int l[Qu],i,k;

for(i=0;i

l[i]=QueueLength(Q[i]);

k=0;

for(i=1;i

if(l[i]

{

l[0]=l[i];

k=i;

}//if

return k;

}//Minimum

Status EnQueue(LinkQueue &Q,QElemType e)

{ // 插入元素e为Q的新的队尾元素

QueuePtr p;

if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败

exit(OVERFLOW);

p->data=e;

p->next=NULL;

Q.rear->next=p;

Q.rear=p;

return OK;

}//EnQueue

Status DeQueue(LinkQueue &Q,QElemType &e)

{ // 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR

QueuePtr p;

if(Q.front==Q.rear)

return ERROR;

p=Q.front->next;

e=p->data;

Q.front->next=p->next;

if(Q.rear==p)

Q.rear=Q.front;

free(p);

return OK;

}//DeQueue

void CustomerArrived()

{

QElemType f;

int durtime,intertime,i;

printf("到达一个客户!");

++CustomerNum;

Random(durtime,intertime);

et.OccurTime=en.OccurTime+intertime; //下一客户到达时刻，隔了intertime来了下一//个客户et.NType=Qu; // 队列中只有一个客户到达事件

if(et.OccurTime

OrderInsert(ev,et,cmp); //不让下一个进入营业厅了

i=Minimum(q); //处理当前进来的人

f.ArrivalTime=en.OccurTime;

f.Duration=durtime;

EnQueue(q[i],f);

printf("排于窗口 %d",i+1);

printf("(到达时间:%d 办理业务耗时:%d)\n",en.OccurTime,durtime);

if(QueueLength(q[i])==1)

{

et.OccurTime=en.OccurTime+durtime;

et.NType=i;

OrderInsert(ev,et,cmp); // 设定第i队列的一个离开事件并插入事件表

}//if

}//CustomerArrived

Status GetHead(LinkQueue Q,QElemType &e)

{ // 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR QueuePtr p;

if(Q.front==Q.rear)

return ERROR;

p=Q.front->next;

e=p->data;

return OK;

}//GetHead

Position GetHead(LinkList L)

{ // 返回线性链表L中头结点的位置

return L.head;

}//GetHead

Status QueueEmpty(LinkQueue Q)

{ // 若Q为空队列,则返回TRUE,否则返回FALSE

if(Q.front==Q.rear)

return TRUE;

else

return FALSE;

}//QueueEmpty

void CustomerDeparture()

{ // 处理客户离开事件，en.NType

int i;

i=en.NType;

DeQueue(q[i],customer);

printf("服务窗口 %d: 离开一个客户!\n",i+1);

TotalTime+=en.OccurTime-customer.ArrivalTime;

if(!QueueEmpty(q[i])) //设定第i队列的一个离开事件，并插入事件表 {

GetHead(q[i],customer);

et.OccurTime=en.OccurTime+customer.Duration;

et.NType=i;

OrderInsert(ev,et,cmp);

}//if

}//CustomerDeparture

Status ListEmpty(LinkList L)

{ // 若线性链表L为空表，则返回TRUE，否则返回FALSE

if(L.len)

return FALSE;

else

return TRUE;

}//ListEmpty

Status DelFirst(LinkList &L,Link h,Link &q) // 形参增加L,因为需修改L

{ // h指向L的一个结点，把h当做头结点，删除链表中的第一个结点并以q返回。

// 若链表为空(h指向尾结点)，q=NULL，返回FALSE

q=h->next;

if(q) // 链表非空

{

h->next=q->next;

if(!h->next) // 删除尾结点

L.tail=h; // 修改尾指针

L.len--;

return OK;

}

else

return FALSE; // 链表空

}//DelFirst

ElemType GetCurElem(Link p)

{ // 已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值

return p->data;

}//GetCurElem

void Bank_Simulation()

{

Link p;

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();

}//while

printf("顾客总数:%d, 所有顾客共耗时:%d分钟, 平均每人耗时: %d分钟\n",CustomerNum,TotalTime,TotalTime/CustomerNum);

}//Bank_Simulation

int main()

{

printf("请输入银行营业时间长度（单位：分）\n");

scanf("%d",&CloseTime);

Bank_Simulation();

return OK;

}