【数据结构】银行业务模拟

2023-10-17 10:30
文章标签 数据结构 模拟 银行业务

本文主要是介绍【数据结构】银行业务模拟，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

 数据结构实现的一个银行业务模拟

代码参考如下： 

/*名称：银行业务模拟 语言：数据结构C语言版 编译环境：VC++ 6.0日期： 2014-3-26 
*/#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <time.h>// 定义事件类型，元素类型
typedef struct Event 
{int OccurTime;	// 事件发生时刻 // 事件类型，Qu表示到达事件,0至Qu-1表示Qu个窗口的离开事件int NType; 
} Event, ElemType;	// 事件类型，有序链表LinkList的数据元素类型 // 线性链表结点类型 
typedef struct LNode
{ElemType data;struct LNode *next;
} LNode, *Link, *Position;// 链表类型 
typedef struct _LinkList
{Link head, tail;	// 分别指向线性链表中的头结点和最后一个结点 int len;			// 指示线性链表中数据元素的个数 
} LinkList;typedef LinkList EventList;	// 事件链表类型，定义为有序链表 // 定义QElemType(队列的数据元素类型) 
typedef struct
{int ArrivalTime;	// 到达时刻 int Duration;		// 办理事务所需时间 
} QElemType;		// 单链队列--队列的链式存储结构 
typedef struct QNode
{QElemType data;struct QNode *next;
}QNode, *QueuePtr;typedef struct
{QueuePtr front,rear;	// 队头、队尾指针 
}LinkQueue;#define Qu 4	// 客户队列数 
#define Khjg 5	// 两相邻到达的客户的时间间隔最大值 
#define Blsj 20 // 每个客户办理业务的时间最大值 // 程序中用到的主要变量(全局)  
EventList ev;			// 事件表 
Event en;				// 事件 
Event et;				// 临时变量 
LinkQueue q[Qu];		// Qu个客户队列 
QElemType customer;		// 客户记录
int CloseTime;			// 银行营业时间(单位是分) 
int TotalTime = 0;		// 累计客户逗留时间初始为0
int	CustomerNum = 0;	// 客户数(初值为0)// 释放p所指结点 
void FreeNode(Link *p)
{ free(*p);*p = NULL;
}// 构造一个空的线性链表。
int InitList(LinkList *L)
{ Link p;p = (Link)malloc(sizeof(LNode));		// 生成头结点 if( p ){p->next = NULL;(*L).head = (*L).tail = p;(*L).len = 0;return 1;}elsereturn 0;
}// 将线性链表L重置为空表，并释放原链表的结点空间 
int ClearList(LinkList *L)
{Link p,q;if((*L).head != (*L).tail)// 不是空表 {p = q = (*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;}return 1;
}// 销毁线性链表L，L不再存在 
int DestroyList(LinkList *L)
{ClearList(L); // 清空链表 FreeNode(&(*L).head);(*L).tail = NULL;(*L).len = 0;return 1;
}// 	h指向L的一个结点，把h当做头结点，删除链表中的第一个结点并以q返回。
//	若链表为空(h指向尾结点)，q=NULL，返回0。 
int DelFirst(LinkList *L,Link h,Link *q) // 形参增加L,因为需修改L 
{*q = h->next;if( *q )	// 链表非空 {h->next = (*q)->next;if( !h->next )		// 删除尾结点 (*L).tail = h;	// 修改尾指针 (*L).len--;return 1;}elsereturn 0; // 链表空 
}// 已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值 
ElemType GetCurElem(Link p)
{return p->data;
}// 	若线性链表L为空表，则返回1，否则返回0。
int ListEmpty(LinkList L)
{if(L.len)return 0;elsereturn 1;
}// 返回线性链表L中头结点的位置 
Position GetHead(LinkList L)
{return L.head;
}/* 
// 依次对L的每个数据元素调用函数visit() 
int ListTraverse(LinkList L,void(*visit)(ElemType))
{Link p = L.head->next;int j;for(j = 1; j <= L.len; j++){visit(p->data);p = p->next;}printf("\n");return 1;
}
*/
// 已知L为有序线性链表，将元素e按非降序插入在L中。（用于一元多项式）
int OrderInsert(LinkList *L,ElemType e,int (*comp)(ElemType,ElemType))
{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 1;
}// 构造一个空队列Q 
int InitQueue(LinkQueue *Q)
{(*Q).front = (*Q).rear = (QueuePtr)malloc(sizeof(QNode));if( !(*Q).front )exit(0);(*Q).front->next = NULL;return 1;
}// 	销毁队列Q(无论空否均可)。
int DestroyQueue(LinkQueue *Q)
{while((*Q).front){(*Q).rear = (*Q).front->next;free((*Q).front);(*Q).front = (*Q).rear;}return 1;
}// 若Q为空队列,则返回1,否则返回0 
int QueueEmpty(LinkQueue Q)
{if(Q.front == Q.rear)return 1;elsereturn 0;
}// 求队列的长度 
int QueueLength(LinkQueue Q)
{int i = 0;QueuePtr p;p = Q.front;while(Q.rear != p){i++;p = p->next;}return i;
}// 若队列不空,则用e返回Q的队头元素,并返回1,否则返回0 
int GetHead_Q(LinkQueue Q,QElemType *e)
{QueuePtr p;if(Q.front == Q.rear)return 0;p = Q.front->next;*e = p->data;return 1;
}// 插入元素e为Q的新的队尾元素 
int EnQueue(LinkQueue *Q,QElemType e)
{QueuePtr p = (QueuePtr)malloc(sizeof(QNode));if( !p ) // 存储分配失败 exit(0);p->data = e;p->next = NULL;(*Q).rear->next = p;(*Q).rear = p;return 1;
}// 若队列不空,删除Q的队头元素,用e返回其值,并返回1,否则返回0。 
int DeQueue(LinkQueue *Q,QElemType *e)
{QueuePtr p;if((*Q).front == (*Q).rear)return 0;p = (*Q).front->next;*e = p->data;(*Q).front->next = p->next;if((*Q).rear == p)(*Q).rear = (*Q).front;free(p);return 1;
}//	从队头到队尾依次对队列Q中每个元素调用函数vi()。
int QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
{QueuePtr p;p = Q.front->next;while( p ){vi(p->data);p = p->next;}printf("\n");return 1;
}// 依事件a的发生时刻<、=或>事件b的发生时刻分别返回-1、0或1。 
int cmp(Event a,Event b)
{if(a.OccurTime == b.OccurTime)return 0;elsereturn (a.OccurTime - b.OccurTime) / abs(a.OccurTime - b.OccurTime);
}// 	银行的开门的时候，进行的初始化操作。
void OpenForDay()
{int i;InitList( &ev );		// 初始化事件链表为空 for(i = 0; i < Qu; ++i)	// 置空各个窗口的队列 InitQueue( &q[i] );en.OccurTime =0;	// 设定第一个客户到达事件 en.NType = Qu;		// 到达 OrderInsert(&ev, en, cmp);	// 插入事件表 
}void Random(int *d,int *i)
{*d = rand() % Blsj + 1;			// 1到Blsj之间的随机数 *i = rand() % Khjg + 1;			// 1到Khjg之间的随机数 printf("\n随机产生，处理时间%d， 间隔%d\n", *d, *i);
}// 	返回最短队列的序号。
int Minimum(LinkQueue Q[]) 
{int l[Qu];int i, k;for(i = 0; i < Qu; i++)l[i] = QueueLength(Q[i]);k = 0;for(i = 1; i < Qu; i++)if(l[i] < l[0]){l[0] = l[i];k = i;}return k;
}// 处理客户到达事件 
void CustomerArrived()
{QElemType f;int durtime, intertime, i;printf("当前时间：%d", en.OccurTime);++CustomerNum;Random(&durtime, &intertime);			// 生成两随机数 et.OccurTime = en.OccurTime + intertime;// 下一客户到达时刻 et.NType = Qu;							// 队列中只有一个客户到达事件 printf("当前客户(%d)的处理时间是%d，下一个客户到达的时间是：%d\n",CustomerNum, durtime, et.OccurTime);if(et.OccurTime < CloseTime)			// 银行尚未关门，插入事件表 OrderInsert(&ev, et, cmp);// 求长度最短队列的序号,等长为最小的序号。然后将这个事件插入到队列中。 i = Minimum(q);f.ArrivalTime = en.OccurTime;f.Duration = durtime;EnQueue(&q[i], f);// 设定第i队列的一个离开事件并插入事件表。 if(1 == QueueLength(q[i])){et.OccurTime = en.OccurTime + durtime;et.NType = i;OrderInsert(&ev, et, cmp);printf("离开事件发生时间是：%d，离开的窗口是%d\n\n", et.OccurTime, et.NType + 1); }
}// 处理客户离开事件，en.NTyPe < Qu 
void CustomerDeparture()
{int i;i = en.NType;DeQueue(&q[i], &customer);	// 删除第i队列的排头客户// 累计客户逗留时间						 TotalTime += en.OccurTime - customer.ArrivalTime; // 设定第i队列的队头为一个离开事件并插入事件表。if( !QueueEmpty(q[i]) ){GetHead_Q(q[i], &customer);et.OccurTime = en.OccurTime + customer.Duration;et.NType = i;OrderInsert(&ev, et, cmp);}
}// 算法3.6 P66 
// 	模拟银行业务，计算客户在银行的逗留时间。 
void Bank_Simulation()
{Link p;ElemType t; OpenForDay();	// 银行开业初始化 // 马上处理事件，判断事件表是否为空while( !ListEmpty(ev) ){// 删除事件表的第一个结点，并返回给p。DelFirst(&ev, GetHead(ev), &p);// 获取刚刚删除的事件结点t = GetCurElem(p);// 从中获取当前时间，当前事件类型。en.OccurTime = t.OccurTime;en.NType = t.NType;if( Qu == en.NType )CustomerArrived();		// 处理客户到达事件 elseCustomerDeparture();	// 处理客户离开事件 }printf("顾客总数:%d, 所有顾客共耗时:%d分钟, 平均每人耗时: %d分钟\n",CustomerNum, TotalTime, TotalTime / CustomerNum);
}int main()
{int i;printf("请输入银行营业时间长度(单位:分)\n");scanf("%d", &CloseTime);srand((unsigned)time(NULL));	// 随机种子 	// 模拟银行事务处理。Bank_Simulation();DestroyList(&ev);for (i = 0; i < Qu; i++)DestroyQueue(&q[i]);system("pause");return 0;
}/*
输出效果：请输入银行营业时间长度(单位:分)
100
当前时间：0
随机产生，处理时间11， 间隔4
当前客户(1)的处理时间是11，下一个客户到达的时间是：4
离开事件发生时间是：11，离开的窗口是1当前时间：4
随机产生，处理时间20， 间隔5
当前客户(2)的处理时间是20，下一个客户到达的时间是：9
离开事件发生时间是：24，离开的窗口是2当前时间：9
随机产生，处理时间1， 间隔3
当前客户(3)的处理时间是1，下一个客户到达的时间是：12
离开事件发生时间是：10，离开的窗口是3当前时间：12
随机产生，处理时间17， 间隔4
当前客户(4)的处理时间是17，下一个客户到达的时间是：16
离开事件发生时间是：29，离开的窗口是1当前时间：16
随机产生，处理时间11， 间隔4
当前客户(5)的处理时间是11，下一个客户到达的时间是：20
离开事件发生时间是：27，离开的窗口是3当前时间：20
随机产生，处理时间1， 间隔3
当前客户(6)的处理时间是1，下一个客户到达的时间是：23
离开事件发生时间是：21，离开的窗口是4当前时间：23
随机产生，处理时间12， 间隔3
当前客户(7)的处理时间是12，下一个客户到达的时间是：26
离开事件发生时间是：35，离开的窗口是4当前时间：26
随机产生，处理时间1， 间隔1
当前客户(8)的处理时间是1，下一个客户到达的时间是：27
离开事件发生时间是：27，离开的窗口是2当前时间：27
随机产生，处理时间10， 间隔2
当前客户(9)的处理时间是10，下一个客户到达的时间是：29
离开事件发生时间是：37，离开的窗口是2当前时间：29
随机产生，处理时间5， 间隔4
当前客户(10)的处理时间是5，下一个客户到达的时间是：33
离开事件发生时间是：34，离开的窗口是3当前时间：33
随机产生，处理时间13， 间隔3
当前客户(11)的处理时间是13，下一个客户到达的时间是：36
离开事件发生时间是：46，离开的窗口是1当前时间：36
随机产生，处理时间13， 间隔1
当前客户(12)的处理时间是13，下一个客户到达的时间是：37
离开事件发生时间是：49，离开的窗口是3当前时间：37
随机产生，处理时间2， 间隔2
当前客户(13)的处理时间是2，下一个客户到达的时间是：39
离开事件发生时间是：39，离开的窗口是4当前时间：39
随机产生，处理时间15， 间隔1
当前客户(14)的处理时间是15，下一个客户到达的时间是：40
离开事件发生时间是：54，离开的窗口是2当前时间：40
随机产生，处理时间1， 间隔4
当前客户(15)的处理时间是1，下一个客户到达的时间是：44
离开事件发生时间是：41，离开的窗口是4当前时间：44
随机产生，处理时间9， 间隔1
当前客户(16)的处理时间是9，下一个客户到达的时间是：45
离开事件发生时间是：53，离开的窗口是4当前时间：45
随机产生，处理时间19， 间隔1
当前客户(17)的处理时间是19，下一个客户到达的时间是：46
当前时间：46
随机产生，处理时间9， 间隔4
当前客户(18)的处理时间是9，下一个客户到达的时间是：50
当前时间：50
随机产生，处理时间14， 间隔2
当前客户(19)的处理时间是14，下一个客户到达的时间是：52
离开事件发生时间是：64，离开的窗口是3当前时间：52
随机产生，处理时间6， 间隔3
当前客户(20)的处理时间是6，下一个客户到达的时间是：55
当前时间：55
随机产生，处理时间10， 间隔5
当前客户(21)的处理时间是10，下一个客户到达的时间是：60
离开事件发生时间是：65，离开的窗口是4当前时间：60
随机产生，处理时间1， 间隔5
当前客户(22)的处理时间是1，下一个客户到达的时间是：65
当前时间：65
随机产生，处理时间15， 间隔1
当前客户(23)的处理时间是15，下一个客户到达的时间是：66
离开事件发生时间是：80，离开的窗口是2当前时间：66
随机产生，处理时间19， 间隔3
当前客户(24)的处理时间是19，下一个客户到达的时间是：69
离开事件发生时间是：85，离开的窗口是3当前时间：69
随机产生，处理时间4， 间隔3
当前客户(25)的处理时间是4，下一个客户到达的时间是：72
离开事件发生时间是：73，离开的窗口是4当前时间：72
随机产生，处理时间20， 间隔3
当前客户(26)的处理时间是20，下一个客户到达的时间是：75
离开事件发生时间是：92，离开的窗口是1当前时间：75
随机产生，处理时间20， 间隔4
当前客户(27)的处理时间是20，下一个客户到达的时间是：79
离开事件发生时间是：95，离开的窗口是4当前时间：79
随机产生，处理时间13， 间隔4
当前客户(28)的处理时间是13，下一个客户到达的时间是：83
当前时间：83
随机产生，处理时间8， 间隔3
当前客户(29)的处理时间是8，下一个客户到达的时间是：86
离开事件发生时间是：91，离开的窗口是2当前时间：86
随机产生，处理时间10， 间隔4
当前客户(30)的处理时间是10，下一个客户到达的时间是：90
离开事件发生时间是：96，离开的窗口是3当前时间：90
随机产生，处理时间4， 间隔4
当前客户(31)的处理时间是4，下一个客户到达的时间是：94
当前时间：94
随机产生，处理时间19， 间隔2
当前客户(32)的处理时间是19，下一个客户到达的时间是：96
当前时间：96
随机产生，处理时间9， 间隔5
当前客户(33)的处理时间是9，下一个客户到达的时间是：101
离开事件发生时间是：105，离开的窗口是2顾客总数:33, 所有顾客共耗时:392分钟, 平均每人耗时: 11分钟
请按任意键继续. . . */

运行结果如下：


这篇关于【数据结构】银行业务模拟的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/224761。

相关文章

【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

前言：快速排序的实现最重要的是找基准值，下面让我们来了解如何实现找基准值 基准值的注释：在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。 在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。 快速排序实现主框架： //快速排序 void QuickSort(int* arr, int left, int rig
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
usaco 1.2 Transformations（模拟）

usaco 1.2 Transformations（模拟）

我的做法就是一个一个情况枚举出来 注意计算公式： （ 变换后的矩阵记为C） 顺时针旋转90°：C[i] [j]=A[n-j-1] [i] （旋转180°和270° 可以多转几个九十度来推） 对称：C[i] [n-j-1]=A[i] [j] 代码有点长 。。。 /*ID: who jayLANG: C++TASK: transform*/#include<
阅读更多...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

上篇：6.1.数据结构-c/c++模拟实现堆上篇（向下，上调整算法，建堆，增删数据）-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小)： 2.2 C语言代码（手写堆） 2.3 C++代码（使用优先级队列 priority_queue）
阅读更多...
hdu4431麻将模拟

hdu4431麻将模拟

给13张牌。问增加哪些牌可以胡牌。 胡牌有以下几种情况： 1、一个对子 + 4组 3个相同的牌或者顺子。 2、7个不同的对子。 3、13幺 贪心的思想： 对于某张牌>=3个，先减去3个相同，再组合顺子。 import java.io.BufferedInputStream;import java.io.BufferedReader;import java.io.IOExcepti
阅读更多...
《数据结构（C语言版）第二版》第八章-排序（8.3-交换排序、8.4-选择排序）

《数据结构（C语言版）第二版》第八章-排序（8.3-交换排序、8.4-选择排序）

8.3 交换排序 8.3.1 冒泡排序 【算法特点】 (1) 稳定排序。 (2) 可用于链式存储结构。 (3) 移动记录次数较多，算法平均时间性能比直接插入排序差。当初始记录无序，n较大时， 此算法不宜采用。 #include <stdio.h>#include <stdlib.h>#define MAXSIZE 26typedef int KeyType;typedef char In
阅读更多...
【每日一题】LeetCode 2181.合并零之间的节点（链表、模拟）

【每日一题】LeetCode 2181.合并零之间的节点（链表、模拟）

【每日一题】LeetCode 2181.合并零之间的节点（链表、模拟） 题目描述 给定一个链表，链表中的每个节点代表一个整数。链表中的整数由 0 分隔开，表示不同的区间。链表的开始和结束节点的值都为 0。任务是将每两个相邻的 0 之间的所有节点合并成一个节点，新节点的值为原区间内所有节点值的和。合并后，需要移除所有的 0，并返回修改后的链表头节点。 思路分析 初始化：创建一个虚拟头节点
阅读更多...
每日一题|牛客竞赛|四舍五入|字符串+贪心+模拟

每日一题|牛客竞赛|四舍五入|字符串+贪心+模拟

每日一题|四舍五入 四舍五入 心有猛虎，细嗅蔷薇。你好朋友，这里是锅巴的C\C++学习笔记，常言道，不积跬步无以至千里，希望有朝一日我们积累的滴水可以击穿顽石。 四舍五入 题目： 牛牛发明了一种新的四舍五入应用于整数，对个位四舍五入，规则如下 12345->12350 12399->12400 输入描述: 输入一个整数n(0<=n<=109 ) 输出描述: 输出一个整数
阅读更多...
【算法专场】模拟（下）

【算法专场】模拟（下）

目录 前言 38. 外观数列 算法分析 算法思路 算法代码 1419. 数青蛙 算法分析 算法思路 算法代码  2671. 频率跟踪器 算法分析 算法思路 算法代码 前言 在前面我们已经讲解了什么是模拟算法，这篇主要是讲解在leetcode上遇到的一些模拟题目~ 38. 外观数列 算法分析 这道题其实就是要将连续且相同的字符替换成字符重复的次数+
阅读更多...
模拟实现vector中的常见接口

模拟实现vector中的常见接口

insert void insert(iterator pos, const T& x){if (_finish == _endofstorage){int n = pos - _start;size_t newcapacity = capacity() == 0 ? 2 : capacity() * 2;reserve(newcapacity);pos = _start + n;//防止迭代
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2