精华内容
下载资源
问答
  • visual C++上写的银行排队系统数据结构的大作业。包含源程序,系统导航和实验报告。
  • 数据结构银行排队系统
  • 数据结构课程设计源代码 银行排队系统 使用C++
  • 适合数据结构大作业的参考
  • Assignment 1ADT Applications Task 2 133490* 实验过程 在这个实验程序中我认为难点在于如何运用队列储存顾客等候情况银行窗口如何 设置实现显示当前顾客序号以及数据的统计和打印 题目描述中有两个模拟版本分别是...
  • 当服务窗口出现空闲时,按既定策略从三种类型客户中选取客户接受服务。 选取客户接受服务的策略如下: (1)三种类型客户的服务优先顺序从高到低依次为:VIP客户、理财客户、一般客户; (2)相同类型的客户采取先来...
  • 包含通用排队系统的代码 比较实用 C编写,用的是队列结构 数据结构银行排队系统
  • 数据结构简单模拟银行排队系统

    千次阅读 多人点赞 2020-06-12 02:06:17
    银行排队系统实现 功能要求: (1) 客户进入排队系统; (2) 客户离开; (3) 查询当前客户前面还有几人; (4) 查询截至目前总共办理多少客户。 输出要求:每进行一次操作后,输出当前排队成员情况。 算法实现 ...

    数据结构 队列

    银行排队系统实现

    功能要求:

    (1) 客户进入排队系统;

    (2) 客户离开;

    (3) 查询当前客户前面还有几人;

    (4) 查询截至目前总共办理多少客户。

    输出要求:每进行一次操作后,输出当前排队成员情况。

    算法实现
    首先创建一个空队列即银行排队队列,再向其中执行插入,删除,查询等操作。在执行插入操作时要判断队列是否已达最大长度,否则不能插入。在删除时要判断队列是否为空,否则不能执行删除操作。删除以后若队列为空,则需要将队尾指向对头。

    #include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    
    #define OK      1
    #define ERROR   0
    #define TRUE 1  
    #define FALSE 0  
    //define the structure node
    
    int m = 0;
    typedef int Status;
    typedef int QElemType;
    
    
    typedef struct queue//结点结构
    {
    	int value;
    	struct queue* next;
    }Queue, *QueuePtr;
    
    
    typedef struct linkqueue
    {
    	Queue *front;//头指针  
    	Queue *tail;//尾指针  
    }LinkQueue;
    
    #define QUEUE_LEN  sizeof(Queue)
    
    
    
    int initQueue(LinkQueue*);//创建一个队列
    
    
    int EmptyQueue(LinkQueue*);//判断队列是否为控
    
    
    int enterQueue(LinkQueue*, int value);//插入元素value为Q的新的队尾元素
    
    
    int deQueue(LinkQueue*);//删除元素
    
    
    int printQueue(LinkQueue*);//输出队列
    
    int Query(LinkQueue*, int);//查询元素myNum在队列中的位置
    
    
    #include<stdio.h>
    #include<stdlib.h>
    
    
    
    
    int initQueue(LinkQueue* Q)//构造一个空队列Q
    {
    	printf("Init a queue ......\n");
    	if (!(Q->front = Q->tail = (Queue*)malloc(QUEUE_LEN)))
    	{
    		printf("ERROR:Malloc Error !\n");
    		return ERROR;
    	}
    	Q->front->next = NULL;
    	return OK;
    }
    
    int enterQueue(LinkQueue* Q, int enterValue)//插入元素enterValue为Q的新的队尾元素
    {
    	Queue* tmpNode = NULL;
    	if (!(tmpNode = (Queue*)malloc(QUEUE_LEN)))
    	{
    		printf("ERROR:Malloc Error !\n");
    		return ERROR;
    	}
    
    	tmpNode->value = enterValue;
    	tmpNode->next = NULL;
    	Q->tail->next = tmpNode;
    	Q->tail = tmpNode;
    
    }
    
    
    int EmptyQueue(LinkQueue *Q) //若队列Q为空,返回TRUE,否则返回FALSE  
    {
    	if (Q->front==Q->tail)
    		
    		return TRUE;
    	else
    
    		return FALSE;
    
    }
    
    int printQueue(LinkQueue* Q)//将队列中每个元素输出
    {
    	Queue* tmpNode = NULL;
    	tmpNode = Q->front->next;
    	if (NULL == tmpNode)
    	{
    		printf("无人排队\n");
    		return ERROR;
    
    	}
    
    	while (tmpNode != Q->tail)
    	{
    		printf("%d  ", tmpNode->value);
    		tmpNode = tmpNode->next;
    	}
    	printf("%d\n", Q->tail->value);
    
    }
    
    int deQueue(LinkQueue*Q, QElemType *e)//若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR
    {
    	QueuePtr p;
    	if (EmptyQueue(Q))
    	{
    		printf("无人离开\n");
    		return ERROR;
    	}
    	p = Q->front->next;
    	*e = p->value;
    	Q->front->next = p->next;
    	m++;
    	if (Q->tail == p)//如果队列中只有一个元素 
    		Q->tail = Q->front;//此时应当让队尾指针指向队头,否则可能将队尾指针释放掉
    	free(p);
    	return OK;
    }
    
    int Query(LinkQueue* Q, int myNum)//查询元素myNum在队列中的位置
    {
    	int numOfMan = 0;
    	if (EmptyQueue(Q))
    	{
    		printf("无人排队\n");
    		return ERROR;
    	}
    	else if (myNum==Q->front->value==Q->tail->value)
    	{
    		return ERROR;
    	}
    	else if (myNum > Q->tail->value || myNum < Q->front->value)
    	{
    		printf("对不起,您输入了一个错误的号码\n");
    		return ERROR;
    	}
    
    	else
    	{
    		numOfMan = myNum -( Q->front->next->value);
    		return  numOfMan;
    	}
    }
    
    #include<stdio.h>
    #include<string.h>
    static  int bankNumber = 0;
    static int totalNumber = 0;
    int stopBank();
    int startBank();
    int flag = 1;
    
    int main()
    {
    	int choice = 0;
    	int d;
    	int num = 0;
    	LinkQueue Q;
    	initQueue(&Q);
    	while (1)
    	{
    		printf("\n\n#########银行排队系统 #############\n");
    		printf("###           1:客户进入排队系统;          \n");
    		printf("###           2:客户离开银行    \n");
    		printf("###           3:查询当前客户前面还有几人                      \n");
    		printf("###           4:查询截止目前总共办理多少客户             \n");
    		printf("###           5:EXIT                        \n");
    		printf("   请选择[1-5]:   ");
    		scanf_s("%d", &choice);
    		switch (choice)
    		{
    		case 1:
    			if (flag)
    			{
    
    				bankNumber++;
    				enterQueue(&Q, bankNumber);
    				totalNumber++;
    				printf("你的等待号码数字 %d\n", bankNumber);
    				printf("%d 人在您之前,请稍等\n", Query(&Q, bankNumber));
    				printf("当前的排队成员情况为:"); printQueue(&Q);
    				break;
    			}
    			else
    			{
    
    				printf("     停止申请号码\n");
    				printf("当前的排队成员情况为:"); printQueue(&Q);
    				break;
    			}
    		case 2:
    			deQueue(&Q,&d);
    			printf("您(%d号)已离开银行 ....\n", d);
    
    			totalNumber--;
    
    			printf("当前的排队成员情况为:"); printQueue(&Q);
    			break;
    		case 3:
    
    			printf("请输入您的号码:\n");
    			scanf_s("%d", &num);
    			printf("%d 人在您之前,请稍等\n", Query(&Q, num));
    
    			printf("当前的排队成员情况为:"); printQueue(&Q);
    			break;
    		case 4:
    			printf("截止目前总共办理%d个客户\n", m);
    			printf("当前的排队成员情况为:"); printQueue(&Q);
    			break;
    		case 5:
    			exit(0);
    			break;
    		default:
    			break;
    
    		}
    
    	}
    
    	return OK;
    }
    
    
    int stopBank()
    {
    	flag = 0;
    
    	return 0;
    }
    
    int startBank()
    
    {
    	flag = 1;
    	return 0;
    
    }

    运行结果在这里插入图片描述

    1、客户进入排队系统在这里插入图片描述

    2、客户离开银行
    在这里插入图片描述

    3、查询当前客户前面还有几人
    在这里插入图片描述

    4、查询截止目前总共办理多少客户
    在这里插入图片描述

    展开全文
  • 因此在客户人数众多时需要在每个窗口前顺次排队, 对于刚进银行的客户。如果某个窗口的业务员正空闲, 则可上前输业务。反之,若个窗口均有客户所占, 他便会排在为数最少的队伍后面。 编制一个程序模拟银行的这种...
  • 数据结构大作业——银行排队系统

    千次阅读 2020-07-08 20:36:36
    数据结构大作业——银行排队系统离散事件模拟——银行业务处理题目分析声明部分辅助函数初始化窗口节点创建顾客节点比较四个窗口的排队人数输出离开顾客的信息主要函数完整的头文件代码 离散事件模拟——银行业务...

    离散事件模拟——银行业务处理

    假设银行有4个窗口为客户服务,某一时刻每个窗口仅能接待一位客户,客户众多时需要排队等候。 请模拟银行一天的业务活动,并统计客户在银行逗留的平均时间。

    题目分析

    根题目的要求,我们可以得到:

    1. 使用队列的数据结构模拟银行中顾客的行为;
    2. 利用一个指针数组来表示银行的四个窗口,并且再添加两个指针数组作为这四个队列的头指针与尾指针;
    3. 加入时间线以确定何时顾客进入,何时离开;
    4. 利用随机数生成顾客的进入与离开的时间;

    声明部分

    handle是用来对后续输出文本进行处理的;TIME是记录顾客在银行逗留的总时间的,用来求平均逗留时间。
    柜台节点中除了一个指针链表,还存有各个柜台实时的排队人数。

    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    #include<windows.h>
    
    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    double TIME = 0.0;
    
    
    typedef struct Truck *Win;
    typedef struct Node *Peo;
    typedef struct Time *Tl;
    
    struct Truck//柜台节点
    {
    	int PeoNum[4];
    	Peo Que[4];
    };
    
    struct Node//人员节点
    {
    	int Num;
    	int ArrTime;//到达时间
    	int Departure;//离开时间
    	Peo Next;
    };
    
    struct Time//记录时间
    {
    	int Note;
    	Tl Next;
    };
    
    Tl Time;//创建离开时间线
    

    辅助函数

    初始化窗口节点

    Win CreatWindows(Win W)
    {
    	for(int i=0;i<4;i++)
    	{
    		W->PeoNum[i] = 0;
    		W->Que[i] = NULL;
    	}
    	return W;
    }
    

    创建顾客节点

    由于每次调用函数时,生成随机数的种子都会新生成一次,这是每次生成的随机数其实是一样的,我们这里在函数外生成随机数,并通过参数ab传入,分别为到达时间与离开时间(以秒表示),num为此顾客的序号。
    之后分别申请顾客节点P与时间节点T,由于我们不关注顾客的到达时间,所以其中时间节点中只储存每个顾客的离开时间。
    最后将新生成的时间节点插入到离开时间线上合适的位置。

    Peo CreatPeople(int a,int b,int num)
    {
    	Peo P = (Peo)malloc(sizeof(struct Node));
    	Tl T = (Tl)malloc(sizeof(struct Time)),q = Time;
    
    	P->ArrTime = a;
    	P->Departure = b;
    	P->Num = num;
    	P->Next = NULL;
    
    	T->Note = b;
    	T->Next = NULL;
    
    	while(q->Next != NULL)
    	{
    		if(q->Next->Note > b)
    			break;
    		q = q->Next;
    	}
    	T->Next = q->Next;
    	q->Next = T;
    	return P;
    }
    

    比较四个窗口的排队人数

    int Compare(Win W)
    {
    	int j = 0;
    	for(int i = 0;i < 4;i++)
    		if(W->PeoNum[i] < W->PeoNum[j])
    			j = i;
    	return j;
    }
    

    输出离开顾客的信息

    这里主要是对输出信息进行了一个处理。

    void ReadInformation(Peo P)
    {
    	char c[4];//存序号
    	int m[3],n[3],//m存开始时间,n存结束时间
    		a = P->Num,b = P->ArrTime,d = P->Departure;
    	for(int i = 3;i >= 0;i--)
    	{
    		c[i] = 48 + a % 10;
    		a /= 10;
    	}
    	m[0] = b/3600+8;//假设8点开始营业
    	b %= 3600;
    	m[1] = b/60;
    	m[2] = b%60;
    	n[0] = d/3600+8;//假设8点开始营业
    	d %= 3600;
    	n[1] = d/60;
    	n[2] = d%60;
    	SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_GREEN);//变绿
    	printf("\n%c%c%c%c - ArriveTime %02d:%02d:%02d - Departure %02d:%02d:%02d\n",
    		c[0],c[1],c[2],c[3],m[0],m[1],m[2],n[0],n[1],n[2]);//输出用户信息(绿色字体)
    }
    

    主要函数

    首先申请窗口节点和离开时间线的头结点并初始化:

    	Win W = (Win)malloc(sizeof(struct Truck));
    	Time = (Tl)malloc(sizeof(struct Time));
    	Tl 	pr;
    
    	Time->Next = NULL;
    	Time->Note = -1;
    	W = CreatWindows(W);//创建窗口
    

    声明首指针与尾指针,创建生成随机数的种子:

    	Peo P,p[4],q[4];//q为首指针,p为尾指针
    	int num = 1,min,i,j,a,b;
    	srand((unsigned)time(NULL));
    

    使用for循环实现时间的流动(模拟时间线):

    	for(i = 0;i < 32400;i++)//假设每天工作9个小时(=32400秒)
    	{
    		if((i == 0 || i == a) && i<31500)//顾客进入
    		{
    			a = rand()%601 + i;//制造一个随机进入时间
    			b = rand()%301 + a;//制造一个随机离开时间
    			TIME += (b - a);
    			P = CreatPeople(a,b,num);//开始制作顾客
    			min = Compare(W);//找到人数最少的窗口
    			if(W->Que[min] == NULL)//将顾客分配到最短队列中
    			{
    				W->Que[min] = P;
    				q[min] = P;
    			}
    			else
    				p[min]->Next = P;
    			p[min] = P;
    			
    			if(q[min] != P)//进到队列中后,需要再加上前一个人的等待时间
    			{
    				Bef = q[min];
    				while(Bef->Next != P)
    					Bef = Bef->Next;
    				P->Departure += (Bef->Departure - i);
    			}
    			
    			W->PeoNum[min]++;
    			num++;
    			
    			if(a == i)//解决两人同时进入的问题
    				i--;
    		}
    		if(Time->Next != NULL && i == Time->Next->Note)//顾客离开
    		{
    			pr = Time->Next;
    			for(j = 0;j < 4;j++)//找到需要离开的顾客所在的窗口
    				if(W->Que[j] != NULL && W->Que[j]->Departure == i)
    					break;
    				
    			ReadInformation(q[j]);//读取离开顾客的数据
    
    			W->Que[j] = q[j]->Next;//出队
    			W->PeoNum[j]--;
    			free(q[j]);
    			q[j] = W->Que[j];
    
    			Time->Next = pr->Next;//删除时间节点
    			free(pr);
    			pr = Time->Next;
    			
    			i--;//解决离开时间相同的问题
    		}
    	}
    

    输出平均逗留时间

    	printf("\nThe average time of stay : %.4f s\n",TIME/num);
    

    完整的头文件代码

    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    #include<windows.h>
    
    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    double TIME = 0.0;
    
    
    typedef struct Truck *Win;
    typedef struct Node *Peo;
    typedef struct Time *Tl;
    
    struct Truck//柜台节点
    {
    	int PeoNum[4];
    	Peo Que[4];
    };
    
    struct Node//人员节点
    {
    	int Num;
    	int ArrTime;
    	int Departure;
    	Peo Next;
    };
    
    struct Time//记录时间
    {
    	int Note;
    	Tl Next;
    };
    
    Tl Time;//创建时间线
    
    
    Win CreatWindows(Win W)
    {
    	for(int i=0;i<4;i++)
    	{
    		W->PeoNum[i] = 0;
    		W->Que[i] = NULL;
    	}
    	return W;
    }
    
    
    Peo CreatPeople(int a,int b,int num)
    {
    	Peo P = (Peo)malloc(sizeof(struct Node));
    	Tl T = (Tl)malloc(sizeof(struct Time)),q = Time;
    
    	P->ArrTime = a;//输入P的参数
    	P->Departure = b;
    	P->Num = num;
    	P->Next = NULL;
    
    	T->Note = b;
    	T->Next = NULL;
    
    	while(q->Next != NULL)
    	{
    		if(q->Next->Note > b)
    			break;
    		q = q->Next;
    	}
    	T->Next = q->Next;
    	q->Next = T;
    	return P;
    }
    
    int Compare(Win W)
    {
    	int j = 0;
    	for(int i = 0;i < 4;i++)
    		if(W->PeoNum[i] < W->PeoNum[j])
    			j = i;
    	return j;
    }
    
    void ReadInformation(Peo P)
    {
    	char c[4];//存序号
    	int m[3],n[3],//m存开始时间,n存结束时间
    		a = P->Num,b = P->ArrTime,d = P->Departure;
    	for(int i = 3;i >= 0;i--)
    	{
    		c[i] = 48 + a % 10;
    		a /= 10;
    	}
    	m[0] = b/3600+8;//假设8点开始营业
    	b %= 3600;
    	m[1] = b/60;
    	m[2] = b%60;
    	n[0] = d/3600+8;//假设8点开始营业
    	d %= 3600;
    	n[1] = d/60;
    	n[2] = d%60;
    	SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_GREEN);//变绿
    	printf("\n%c%c%c%c - ArriveTime %02d:%02d:%02d - Departure %02d:%02d:%02d\n",
    		c[0],c[1],c[2],c[3],m[0],m[1],m[2],n[0],n[1],n[2]);//输出用户信息(绿色字体)
    }
    
    void TimeLine()
    {
    	Win W = (Win)malloc(sizeof(struct Truck));
    	Time = (Tl)malloc(sizeof(struct Time));
    	Tl 	pr;
    
    	Time->Next = NULL;
    	Time->Note = -1;
    
    	SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_RED);//变红
    	printf("Commence business!\n\n\n");
    	Sleep(1000);
    
    	Peo P,p[4],q[4];//q为首指针,p为尾指针
    	int num = 1,min,i,j,a,b;
    
    	W = CreatWindows(W);//创建窗口
    //	SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_GREEN);//变绿
    
    	srand((unsigned)time(NULL));
    	for(i = 0;i < 32400;i++)//假设每天工作9个小时(=32400秒)
    	{
    		if((i == 0 || i == a) && i<31500)//入队
    		{
    			a = rand()%601 + i;//制造一个随机进入时间
    			b = rand()%301 + a;//制造一个随机离开时间
    			TIME += (b - a);
    			P = CreatPeople(a,b,num);//开始制作顾客
    			min = Compare(W);
    			if(W->Que[min] == NULL)//将顾客分配到最短队列中
    			{
    				W->Que[min] = P;
    				q[min] = P;
    			}
    			else
    				p[min]->Next = P;
    			p[min] = P;
    			if(q[min] != P)//进到队列中后,需要再加上前一个人的等待时间
    			{
    				Bef = q[min];
    				while(Bef->Next != P)
    					Bef = Bef->Next;
    				P->Departure += (Bef->Departure - i);
    			}
    			W->PeoNum[min]++;
    			num++;
    			if(a == i)
    				i--;//解决两人同时进入的问题
    		}
    		if(Time->Next != NULL && i == Time->Next->Note)//出队
    		{
    			pr = Time->Next;
    			for(j = 0;j < 4;j++)
    				if(W->Que[j] != NULL && W->Que[j]->Departure == i)
    					break;
    			Sleep(50);
    			ReadInformation(q[j]);
    
    			W->Que[j] = q[j]->Next;
    			W->PeoNum[j]--;
    			free(q[j]);
    			q[j] = W->Que[j];
    
    			Time->Next = pr->Next;
    			free(pr);
    			pr = Time->Next;
    			i--;//解决离开时间相同的问题
    		}
    	}
    	printf("\nThe average time of stay : %.4f s\n",TIME/num);
    	SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY | FOREGROUND_RED);//变红
    	printf("\nClose the door!\n");
    	SetConsoleTextAttribute(handle, FOREGROUND_INTENSITY);//变白
    }
    
    展开全文
  • 数据结构队列的简单应用--银行排队系统的模拟
  • 银行排队系统模拟—数据结构

    万次阅读 多人点赞 2017-05-23 15:12:19
    银行排队系统模拟—数据结构 假设某银行有n个窗口对外接待客户,从早晨银行9点开门起到5点关门,不断有客户进入银行,由于每个窗口在某个时刻只能接待一个客户。因此在客户人数众多时需要在每个窗口前顺次排队,对于...
                              银行排队系统模拟—数据结构
    

    假设某银行有n个窗口对外接待客户,从早晨银行9点开门起到5点关门,不断有客户进入银行,由于每个窗口在某个时刻只能接待一个客户。因此在客户人数众多时需要在每个窗口前顺次排队,对于刚进银行的客户。如果某个窗口的业务员正空闲,则可上前输业务。反之,若个窗口均有客户所占,他便会排在为数最少的队伍后面。编制一个程序模拟银行的这种业务活动并计算一天中客户在银行的平均逗留时间。
    首先从题目分析:N个窗口排队,首先就要建立N个队列来存储排队的用户信息 ,然后算出那个队列最短就用户就到那个队伍排队,同时通过随机生成他办理业务的时间和到来的时间,通过计算用户的到来时间和离开时间就可以计算出某个用户在银行的逗留时间 ;话不多说直接上代码。

    1,首先定义队列,存储用户的到达时间,离开时间,,等待时间,办理业务时间,开始办理时间

    typedef struct Node
    {
        int arrivd_time; //到达时间
        int wait_time;  //等待时间
        int leave_time; //离开时间
        int business_time; //办理业务时间
        int star_time;   //开始办理时间
        Node *next;
    }Time_data;
    struct Queue
    {
        Node *front; 
        Node *rear;
    };
    //队列初始化
    void initQueue(Queue *q)
    {
        q->front = q->rear = (Node *)malloc(sizeof(Node));
        if (!q->front)
        {
            return;
        }
        q->front->next = NULL;
    }
    //判断队空
    int isEmpty(Queue *q)
    {
        if (q->front == q->rear)
        {
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
    //入队
    void Enqueue(Queue *q, Time_data *data)
    {
        Node *repareInsert = (Node *)malloc(sizeof(Node));
        Time_data *temp_data = data;
        if (repareInsert == NULL)
        {
            exit(0);
        }
        q->rear->arrivd_time = temp_data->arrivd_time;
        q->rear->wait_time = temp_data->wait_time;
        q->rear->leave_time = temp_data->leave_time;
        q->rear->business_time = temp_data->business_time;
        q->rear->star_time = temp_data->star_time;
        q->rear->next = repareInsert;
        q->rear = repareInsert;
    }

    2,定义一个数组存放四个队列并初始化

    Queue first_queue, second_queue, three_queue,five_queue;//定义四个队列
    Queue queue[QUEUE_SUM] = { first_queue ,second_queue ,three_queue,five_queue };
    //初始化队列
    for (int i = 0; i < QUEUE_SUM; i++)
        {
            initQueue(&queue[i]);
        }

    下面是主函数,由用户输入银行上下班时间,计算营业多长时间Total_time,如何当前时间小于关门的时间,就一直进入customer_into();函数,用户不断的进来

     #define FALSE 0
    #define TRUE 1
    #define QUEUE_SUM 4  //窗口的数量
    
    int rand_business_time=0, rand_wait_time=0;//定义办理时间,等待时间变量
    int Total_time=0,now_tim=0;//总时间,当前时间
    int go_time[4] = {0,0,0,0};//定义数组存储每个窗口最后一位办理完业务的时间
    int sum_nan[4] = {0,0,0,0};//定义数组存储每个窗口排队的人数
    int Sign=TRUE;  //是否关门标志位
    float Sum_Wait_Time=0.0;  //等待的总时间
    float Sun_Nan=0.0;  //总人数
    int open_time;//开门时间
    int off_time; //关门时间
    int main()
    {
        Prompted();
        printf("输入银行的24小时制营业时间:如营业时间为9:00--17:00,则应输入:9,17\n");
        scanf("%d,%d", &open_time,&off_time);
        Total_time = (off_time - open_time) * 60;//计算银行总营业多少分钟
        for (int i = 0; i < QUEUE_SUM; i++)
        {
            initQueue(&queue[i]);//初始化队列
        }
        printf("在银行关门前办理完的客户\n");
        while (Total_time>now_time)
        {
            customer_into(); //客户进入函数
        }
        printf("银行关门时间到不再接收客人\n\n");
        for (int i = 0; i < QUEUE_SUM; i++)
        {
            DisposeQueue(&queue[i],i);//输入在银行关门前还没有办理完业务的客户信息
        }
        printf("平均时间为%.2f分钟",Sum_Wait_Time/Sun_Nan);  /*通过各个客户的总等待时间总和/总人数算出逗留平均时间*/
        _getch();
        return 0;
    }

    下面的客户进来函数,首先通过生成两个随机数 rand_business_time办理业务的时间,rand_wait_time这个人用户与上一个用户进来银行的时间差,其他的下面注释已经写的很清楚了

    //用户进队函数
    void customer_into() {
        int which_queue_free = 0;
        rand_time();//获取两个随机数
        Leave_Queue();//查询各个队列的队首的那个客户是否已经办理完业务
        Leave_Queue();//如何办理完就出队,进行四个查询,是因为有可能下一个用户到来前某个队列
        Leave_Queue();//有多个用户办理完业务,离开。因为每个用户到来的时间间隔控制在五分钟内
        Leave_Queue();//用户办理时间控制在1分钟到30分钟内所以四次判断即可
        which_queue_free = Fing_Queue_free();//获取那个队列最短
        if (Sign)//判断是否已经到了关门时间
        {
            Time_data *data;  //定义一个结构体
            data = (Time_data*)malloc(sizeof(Time_data)); 
            data->arrivd_time = now_time;//存储用户到来的时间
            data->business_time = rand_business_time;//存储用户办理业务的时间
            if (go_time[which_queue_free] == 0||now_time>go_time[which_queue_free])
            /*判断当前队列是否为空*/
            {
                data->leave_time = now_time + rand_business_time;//离开时间等现在时间加办理完业务的时间
                data->wait_time = rand_business_time;//逗留时间等于办理业务的时间
                data->star_time = now_time; //开始办理业务时间等于当前时间
            }
            else
            {
            //如果当前队列不为空
                data->leave_time = go_time[which_queue_free] + rand_business_time;//离开时间等于上一个人离开时间加上办理业务的时间
                data->wait_time = go_time[which_queue_free] - now_time + rand_business_time;//逗留时间等于上一个用户办理完业务的时间减去现在的时间加上办理业务的时间
                data->star_time = go_time[which_queue_free];//开始办理业务的时间等于上一个用户办理完业务的时间
            }
            go_time[which_queue_free] = data->leave_time;//存储这个队列最后一位离开的时间
            sum_nan[which_queue_free] = sum_nan[which_queue_free] + 1;//存储这个队列的人数
            Enqueue(&queue[which_queue_free], data);//进队
        }
    }

    下面是判断哪个队列的队首客户是否已经办理完业务,并进行出队,和随机时间函数

    //各个队列办理完业务出队函数
    void Leave_Queue() {
        for (int i = 0; i <QUEUE_SUM; i++)
        {
            if(Sign)
            {
                if (!isEmpty(&queue[i]))
                {
                    //Leave_Queue(&queue[i]);
                    if (Leave_Queue(&queue[i], i))//如何用户出队
                    {
                        sum_nan[i]--;该队伍人数减一
                        Sun_Nan++;  //总人数加一
                    }
    
                }
            }
        }
    }
    //产生随机数时间
    void rand_time() {
        srand((unsigned)time(NULL));  //用时间作为种子对随机数进行操作
        rand_business_time = rand() % 30 + 1;  //任何一个客户的办理业务时间在1-30之间
        rand_wait_time = rand() % 5 + 1;   //任何两个客户到达的时间间隔不超过5分钟,1-5
        now_time += rand_wait_time;//当前时间
        if (Total_time <now_time) {//判断是否到了关门时间
            Sign = FALSE;
        }
        Sleep(1000);  //由于随机函数的产生机制导致在一秒以内产生的随机数都是相同的,因此在一次使用Random时需要进行延时
    }

    下面是出队函数,判断符合条件的队首元素进行出队出来

    //出队函数
    int Leave_Queue(Queue *q,int i)
    {
        Node *FrontTmp = q->front;
        int start=0;
        int leave=0;
        int wait = 0;
        int business = 0;
        int with_me;
        int arr_h = 0;  //到达时间的小时位
        int arr_m = 0;  //到达时间的分钟位
    
        int lea_h = 0;  //离开时间的小时位
        int lea_m = 0;  //离开时间的分钟位
    
        int start_h = 0; //开始办理时间的小时位
        int start_m = 0; //开始办理时间的分钟位
        if (FrontTmp->leave_time <= now_time)//判断离开时间是否小于当前时间
        {
            start = FrontTmp->arrivd_time;
            arr_h = open_time + start / 60;
            arr_m = start % 60;
    
            leave = FrontTmp->leave_time;
            lea_h = open_time + leave / 60;
            lea_m =  leave % 60;
    
            wait = FrontTmp->wait_time;
            business = FrontTmp->business_time;
    
            with_me = FrontTmp->star_time;
            start_h = open_time + with_me / 60;
            start_m =  with_me % 60;
    
            printf("办理窗口:%d 号窗口\t到达:%d:%d \t离开:%d:%d \t等待:%d 分钟\t业务:%d 分钟\t开始办理:%d:%d\n", ++i, arr_h, arr_m, lea_h, lea_m, wait, business, start_h, start_m);
            Sum_Wait_Time = Sum_Wait_Time + wait;
            if (isEmpty(q))//判断队列是否为空
            {
                printf("BUG\n");
                return FALSE;
            }
            if (q->front == q->rear)//如果队列只有一个元素
            {
                q->front = q->rear = NULL;
                return TRUE;
            }
            Node *FrontTmp1 = q->front;//进行出队
            q->front = q->front->next;
            free(FrontTmp1);
            return TRUE;
        }
        return FALSE;
    }

    最后对银行关门时间到了,还在办理业务的客户和还在排队的客户进行出队处理,还在办理的客户允许继续办理完业务在离开,还在排队的进马上离开

    //队的遍历
    void DisposeQueue(Queue *q,int i)
    {
        Node *FrontTmp = q->front;
        int sun=0;//统计队列的元素的个数
        int Window = i + 1;
        int wait; //逗留时间
        int leave= Total_time;
        int start = 0;
        int leave1 = 0;
        int wait1 = 0;
        int business = 0;
        int with_me;
        int arr_h = 0;  //到达时间的小时位
        int arr_m = 0;  //到达时间的分钟位
    
        int lea_h = 0;  //离开时间的小时位
        int lea_m = 0;  //离开时间的分钟位
    
        int start_h = 0; //开始办理时间的小时位
        int start_m = 0; //开始办理时间的分钟位
        while (FrontTmp != q->rear)
        {
            start = FrontTmp->arrivd_time;
            arr_h = open_time + start / 60;
            arr_m =  start % 60;
    
            leave1 = FrontTmp->leave_time;
            lea_h = open_time + leave1 / 60;
            lea_m =  leave1 % 60;
    
            wait1 = FrontTmp->wait_time;
            business = FrontTmp->business_time;
    
            with_me = FrontTmp->star_time;
            start_h = open_time + with_me / 60;
            start_m =  with_me % 60;
            sun++;
            if (FrontTmp->star_time < Total_time)
            {
                printf("银行关门前已经在办理业务的\n");
                wait = FrontTmp->wait_time;
                leave = FrontTmp->leave_time;
                printf("办理窗口:%d 号窗口\t到达:%d:%d \t离开:%d:%d \t等待:%d 分钟\t业务:%d 分钟\t开始办理:%d:%d\n", Window, arr_h, arr_m, lea_h, lea_m, wait1, business, start_h, start_m);
            }
            else
            {
                printf("银行关门后还在排队的\n");
             wait =(Total_time - FrontTmp->arrivd_time);
             leave = Total_time;
             printf("办理窗口:%d 号窗口\t到达:%d:%d \t离开:%d:00\t等待:%d 分钟\t没有办理业务\n\n", Window, arr_h, arr_m, off_time, wait);
            }
    
            FrontTmp = FrontTmp->next;
            Sum_Wait_Time += wait;//总等待时间
        }
        Sun_Nan = Sun_Nan + sun;//总人数
    }

    下面是运行结果截图

    这里写图片描述

    这里写图片描述

    以上代码如有不足之处,或者需要改进之处,敬请指出。

    源码下载链接:http://download.csdn.net/detail/qq_36480491/9849833

    展开全文
  • 数据结构课程设计C语言,用到知识数据结构中的队列,课程设计
  • 银行排队系统

    银行排队系统

    【问题描述】假设银行只有2个窗口对外营业,顾客到银行办理业务,首先要取一个顺序号,然后排队等待叫号。被叫到号的顾客到柜台接受服务,服务完毕后离开。到了下班时间不再接收新来的顾客。顾客分为普通顾客和VIP顾客,VIP顾客有优先权,即可以先得到服务。编一算法模拟银行的每个窗口一天各有多少顾客接受了服务,其中有多少个VIP顾客;并按逆序输出接受服务的普通顾客和VIP顾客的顺序号。
    【问题分析】
    顾客到银行办理业务,必须按照先来先得到服务的原则,因此可以把顾客信息用一个队列来存储,顾客到达后先取号,然后进入队列(插入队尾)等待;被叫到号的顾客接受服务,然后离开(队头元素出列);银行下班后不再接收新来的顾客,即将队列中的元素依次出队列。VIP顾客可以优先得到服务,即可以把VIP顾客单独放在一个队列中,当顾客需要接受服务时 ,首先判断VIP队列是否为空,如不为空,则VIP队列的第一个顾客接受服务;当为空时,则普通队列的第一个顾客接受服务。到达银行的顾客的顺序号随机产生(1-100之间)。顾客的等级也可随机产生(比如;1表示VIP顾客;0表示普通顾客)。设置命令:A表示顾客到达银行;D表示顾客离开银行;P表示下班不再接收新顾客。为了逆序输出已接受服务的顾客顺序号,可以设置一个栈,在顾客接受完服务后,将顾客的顺序号存入栈中,待下班后,依次取出栈中元素并输出,即为所求。
    【实现提示】
    本题采用2个带头结点的链队列和一个顺序栈作为存储结构。
    输入设计:当输入命令A时,进行入队操作;当输入D时,进行出队操作;当输入P时,如果排队队列不空,则依次删除所有元素。在删除元素的过程中,把删除的元素同时入栈,并计数。
    输出设计:输出进入银行排队的总人数和逆序输出排队的顾客顺序号。
    说明:可以不按“实现提示”做,由自己任意发挥。

    #include <iostream>
    #include<stdio.h>
    #include<string.h>
    #include<math.h>
    #include<stdlib.h>
    #include<algorithm>
    using namespace std;
    #define STACK_INIT_SIZE 100
    #define STACKINCREMENT 10
    typedef struct node
    {
        ///结点构造
        int date;///顾客顺序号
        struct node *next;///指针域
    } LinkQnode;
    typedef struct
    {
        ///链队列结构
        LinkQnode *front;///队头指针
        LinkQnode *rear;///队队尾指针
    } LinkQueue;
    typedef struct/**顺序栈结构**/
    {
        int *base;
        int *top;
        int Stacksize;
    } SeqStack;
    void InitLinkQueue(LinkQueue *Q1, LinkQueue *Q2)
    {
        Q1->front = (LinkQnode *)malloc(sizeof(LinkQnode));
        Q1->rear = Q1->front;
        Q1->front->next = NULL;
        Q2->front = (LinkQnode *)malloc(sizeof(LinkQnode));
        Q2->rear = Q2->front;
        Q2->front->next = NULL;
    }
    void InitStack(SeqStack *S)
    {
        S->base = (int *)malloc(100 * sizeof(int));
        if(!S->base)
            printf("空间已满\n");
        else
        {
            S->top = S->base;
            S->Stacksize = 100;
        }
    }
    int EnLinkQueue(LinkQueue *Q, int x)
    {
        LinkQnode *Newnode;
        Newnode = (LinkQnode *)malloc(sizeof(LinkQnode));
        if(Newnode != NULL)
        {
            Newnode->date = x;
            Newnode->next = NULL;
            Q->rear->next = Newnode;
            Q->rear = Newnode;
            printf("序号为%d的顾客进入\n", Q->rear->date);
            return 1;
        }
        else
            return 0;
    }
    int DeLinkQueue(LinkQueue *Q, int *x)
    {
        LinkQnode *p;
        if(Q->front == Q->rear)
            return 0;
        p = Q->front->next;
        Q->front->next = p->next;
        if(Q->rear == p)
        {
            Q->rear = Q->front;
        }
        *x = p->date;
        free(p);
        return 1;
    }
    int Push(SeqStack *S, int x)
    {
        if(S->top - S->base == S->Stacksize)
        {
            S->base = (int *)realloc(S->base, (S->Stacksize + 10) * sizeof(int));
            if(S->base == NULL)
                return 0;
            S->top = S->base + S->Stacksize;
            S->Stacksize = S->Stacksize + 10;
        }
        *S->top = x;
        S->top++;
        return 1;
    }
    int IsLQEmpty(LinkQueue *Q)
    {
        if(Q->front == Q->rear)
            return 1;
        else
            return 0;
    }
    int IsEmpty(SeqStack *S)
    {
        if(S->top == S->base)
            return 1;
        else
            return 0;
    }
    int Pop(SeqStack *S, int *x)
    {
        if(S->top == S->base)
            return 0;
        else
        {
            S->top--;
            *x = *S->top;
            return 1;
        }
    }
    void Process(LinkQueue *Q1, LinkQueue *Q2, SeqStack *S)
    {
        char ch;
        int flag, sum = 0, ans = 1, cnt = 0;
        int num1=0,num2=0,num=0;
        printf("------------------银行排队系统模拟------------------\n");
        printf("  A--表示顾客到达\n  D--表示顾客离开\n  P--表示停止顾客进入\n");
        printf("1表示顾客属于VIP顾客,0表示顾客属于普通顾客\n");
        printf("请输入:A/D/P及0/1\n");
        flag = 1;
        while(flag)
        {
            cin >> ch;
            switch(ch)
            {
            case 'A':
                cin >> cnt;
                if(ans <= 2)
                {
                    num1++;
                    num2++;
                    num++;
                    if(cnt == 1)
                    {
                        EnLinkQueue(Q1, num1);
                        Push(S, num);
                        printf("顾客号为%d的VIP顾客正在接受服务\n", num1);
                        //break;
                    }
                    else if(cnt == 0)
                    {
                        EnLinkQueue(Q2, num2);
                        Push(S, num1);
                        printf("顾客号为%d的普通顾客正在接受服务\n", num2);
                        //break;
                    }
                    ans++;
                    break;
                }
                else if(ans > 2)
                {
                    if(cnt == 0)
                    {
                        num++;
                        EnLinkQueue(Q2, num);
                        printf("请顺序号为%d的普通顾客等待\n", num);
                        //break;
                    }
                    else if(cnt == 1)
                    {
                        num++;
                        EnLinkQueue(Q1, num);
                        printf("请顺序号为%d的VIP顾客等待\n", num);
                        //break;
                    }
                }
                break;
            case 'D':
                if(!IsLQEmpty(Q1))//
                {
                    DeLinkQueue(Q1,&num);
                    sum=sum+1;///已接受服务的顾客数
                    printf("请序号为%d的VIP顾客离开\n",num);
                    Push(S,num);
                }
                else if(IsLQEmpty(Q1)&&(!IsLQEmpty(Q2)))
                {
                    DeLinkQueue(Q2,&num);
                    sum=sum+1;
                    printf("请序号为%d的普通顾客离开\n",num);
                }
                else if(IsLQEmpty(Q1)&&IsLQEmpty(Q2))
                {
                    printf("无顾客排队\n");
                }
                break;
            case 'P':
                printf("停止顾客进入\n");
                printf("还在排队的顾客有:\n");
                while(!IsLQEmpty(Q1))
                {
                    DeLinkQueue(Q1,&num);
                    printf("还在排队的VIP顾客号%d\n",num);
                    sum=sum+1;
                    Push(S,num);
                }
                while(!IsLQEmpty(Q2))
                {
                    DeLinkQueue(Q2,&num);
                    printf("还在排队的普通顾客号%d\n",num);
                    sum=sum+1;
                    Push(S,num);
                }
                flag=0;
                break;
            }
        }
        printf("到达银行的顾客人数为%d\n",sum);
        while(!IsEmpty(S))
        {
            Pop(S,&num);
            printf("第%d位顾客,序号为%d\n",sum,num);
            sum--;
        }
    
    }
    int main()
    {
        LinkQueue *Q1, *Q2;
        SeqStack *S;
        Q1 = (LinkQueue *)malloc(sizeof(LinkQueue));
        Q2 = (LinkQueue *)malloc(sizeof(LinkQueue));
        S = (SeqStack *)malloc(sizeof(SeqStack));
        InitLinkQueue(Q1, Q2);
        InitStack(S);
        Process(Q1, Q2, S);
        return 0;
    }
    
    
    展开全文
  • 单队列–银行排队系统 项目名称:银行业务之单队列多窗口服务 1 实验目的 熟练掌握队列的基本操作,理解队列的应用。 2 实验内容 假设银行有K个窗口提供服务,窗口前设一条黄线,所有顾客按到达时间在黄线后排成一条...
  • 数据结构银行叫号系统

    千次阅读 2018-11-09 17:34:34
    数据结构银行叫号系统 针对前辈的银行叫号系统有bug,并不能完美实现叫号操作,晚辈提出一点修改意见,如有不对,希望指正! 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器...
  • 银行预约排队系统(数据结构问题)》由会员分享,可在线阅读,更多相关《银行预约排队系统(数据结构问题)(25页珍藏版)》请在人人文库网上搜索。1、预约排队系统 第三小组: 孙鹏飞问题分析 朱思敏结构算法 周华毅...
  • (贵州大学计算机科学与信息学院贡献) #include <stdio.h> #include <malloc.h> #include <stdlib.h> #include <conio.h> #include <time.h> #define n 3 int vip1=0; int y,z; float sum1=0,sum2=0,sum3=0,sum4=0,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,597
精华内容 2,638
关键字:

数据结构银行排队系统

数据结构 订阅