【数据结构与算法（C语言）】离散事件模拟- 单链表和队列的混合实际应用

已于 2024-06-17 11:03:19 修改
阅读量877 收藏 9
点赞数 27
分类专栏： 数据结构与算法 文章标签： c语言 数据库 开发语言
于 2024-06-17 10:40:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiweiliude2/article/details/139728143
版权

目录

1. 前言

  假设银行有4个窗口对外接待客户，从早晨银行开门不断有客户进入银行。每个客户总是排队到人员最少的窗口办理业务。现在需要编写一个程序以模拟银行的这种业务并计算一天中银行逗留的平均时间。
  为了计算这个平均时间，只需要将每个客户的离开银行时间减去到达银行时间得到一个客户的逗留事件，将所有客户的时间总和除以客户数就是所有的平均时间。称客户到达银行和离开银行这两个时刻发生的事情为事件,则整个模拟程序将按事件发生的先后顺序进行处理，这样一种模拟程序称作事件驱动模拟。

2. 流程图

在这里插入图片描述

3. 数据结构

  需要两种数据结构：有序单链表和链式队列。

3.1 单链表

  单链表用于存放事件，事件分类为两类：一类客户到达事件；另一类客户离开事件。事件按照发生时刻按照顺序存放在单链表中。

3.2 链式队列

  4个队列分别模拟4个窗口，用于存放排队的客户。客户信息主要包括客户的编号、客户到达的时候、客户办理业务的时间。因为客户的人数不确定，所以使用链式存储方式。

4. 核心函数

  为了让程序更加清晰，本文不详细介绍队列和单链表的实现，具体实现详解可查看以往的博客《线性表-单链表》和《队列-链队列》，本博文直接展示如何使用这些数据结构。
  核心函数只有4个：银行业务模拟总函数 void BankSimulation()、银行开始营业(初始化) void OpenForDay()、客户达到函数 void CustomerArrived(Event en) 、客户离开函数void CustomerDeparture(Event en)。

4.1 银行业务模拟 void BankSimulation()

功能：银行业务的总体运行，其他所有函数都包含在此函数中。
   主要包含一个循环，每次从事件链表中提取一个事件，并根据事件类型来驱动具体的流程。这个流程包括客户达（入列），客户离开（出列）。
实现：

void BankSimulation(){
	Event e;
	srand((unsigned)time(NULL));//使用时间生成一个随机种子
	OpenForDay();
	while(!ListEmpty(eventList))
	{
		ListDelFstNode(&eventList, &e); //从链表中提取一个事件
		if(e.nType==0)								//事件类型0，即客户到达
			CustomerArrived(e);				  //客户到达
		else 
			CustomerDeparture(e);			  //客户离开

		/*下面几行就是打印当前链表和队列*/
		printf("\n事件链表： ");
		ListTraverse(eventList);
		printf("\n\n");
		PrintQueues();
		printf("\n\n");

	}
	printf("每个客户平均时间:%f",(float)TotalTime/CustomerNumber);
	DestoryDataStruct();//最后销毁链表和数据结构，释放内存空间
}

4.2 初始化 void OpenForDay()

功能：银行开门，即初始化函数。
   初始化事件链表、4个队列，同时生成第一个客户的到达事件，插入到事件链表中。
实现：

void OpenForDay()
{
	int i;
	InitList(&eventList);
	ListInsertByOrder(&eventList, NewEvent(0,0));
	for(i=0;i<4;i++)
		InitQueue(&queue[i]);
}

4.3 客户到达 void CustomerArrived(Event en)

功能：客户到达，主要功能有以下三个。
    a). 生成一个新的客户到达事件，插入到事件链表中；
    b). 将事件en中的刚到达客户信息插入到最短的队列中；
    c). 如果队列 插入前是空队列，则生成一个离开事件插入到事件链表中（空队列，说明客户到队列中，业务就立马办理了，无需等待)。
实现：

/*	事件en到达，主要有以下功能
	1. 生成一个新的客户到达事件，插入到事件链表中
	2. 将事件en中的刚到达客户信息插入到最短的队列中；
	3. 如果队列 插入前是空队列，则生成一个离开事件插入到事件链表中（空队列，说明客户到队列中，业务就立马办理了，无需等待)
*/
void CustomerArrived(Event en)
{	
	int i,duration;	//duration当前到达事件中的客户办理业务的持续时间
	int interTime_newCustomer;   // 新生成客户达到的间隔时间；
	int arrivalTime_newCustomer; //新生成客户的到达事件
	interTime_newCustomer = rand()%5 + 1;//新生成客户到达时间设置5分钟之内
	duration = rand()%30 + 1;			 //当前到达客户业务办理时间在30分钟
	arrivalTime_newCustomer = en.occurTime+interTime_newCustomer ;
	printf("时刻 %d: %d号 客户到达;\n",en.occurTime,++CustomerNumber);
	if(arrivalTime_newCustomer < CloseTime)
	ListInsertByOrder(&eventList,NewEvent(arrivalTime_newCustomer,0)); //生成一个新的客户到达事件插入到事件链表中

	i=ShortestQueueIndex();
	EnQueue(&queue[i],NewCustomer(CustomerNumber,en.occurTime,duration)); //到达客户入列
	if(QueueLength(queue[i])==1)//插入之前是空队列
		ListInsertByOrder(&eventList,NewEvent(en.occurTime+duration,i+1));//生成一个离开事件插入到事件链表中
}

4.4 客户离开 void CustomerArrived(Event en)

功能：客户到达，主要功能有以下两个。
    a).从队列中删除客户，打印离开信息，统计总用时;
    b). 如果队列不空，则获取队列（删除客户）的下一个客户，以表示下一个客户开始办理业务，并将这个客户的离开事件插入到事件链表中去。
实现：

// 顾客离开事件
// 功能1 ：从队列中删除客户，打印离开信息，统计总用时; 
// 功能2 ：如果队列不空，则获取队列（删除客户）的下一个客户，
//		   以表示下一个客户开始办理业务，并将这个客户的离开事件插入到LinkList中去。
void CustomerDeparture(Event en)
{
	int i=en.nType-1;
	QElemType customer;
	DeQueue(&queue[i],&customer);
	printf("时刻 %d: %d号 客户离开;\n",en.occurTime,customer.number);
	TotalTime += en.occurTime - customer.arrivalTime;
	if(!QueueEmpty(queue[i])){
		GetHead(queue[i],&customer); //从队列中获取下一个客户
		ListInsertByOrder(&eventList,NewEvent(en.occurTime+customer.duration,i+1));//下个客户的离开事件插入事件链表
	}
}

5. 非核心函数

除了上面4个核心函数，还有几个非核心函数。很简单，无需花时间去理解。如生成新的事件、生成新的客户、获取长达字段的队列等等

5.1 新建客户 NewCustomer

功能：新建一个客户信息的元素（队列的元素）
实现：

/*新建一个客户信息的元素（队列的元素）*/
QElemType NewCustomer(int number, int arrivalTime,int duration)
{
	QElemType e;
	e.number=number;
	e.arrivalTime=arrivalTime;
	e.duration=duration;
	return e;
}

5.2 新建事件 NewEvent

功能：新建一个事件（单链表结点中的数据）
实现：

/*新建一个事件（单链表结点中的数据）*/
ElemType NewEvent(int occurTime,int nType)
{
	Event e;
	e.occurTime=occurTime;
	e.nType=nType;
	return e;
}

5.3 查找最短的队列 ShortestQueueIndex

功能：查找长度最短的队列
实现：

/*在队列数组中查找长度最短的队列，并返回其下标*/
int ShortestQueueIndex()
{
	int i,minQueueIndex=0;			 //minQueueIndex 最短队列下标
	int minLen=QueueLength(queue[0]);//定义一个最小长度变量
	for(i=1;i<4;i++)
	{
		if(minLen>QueueLength(queue[i])){
			minLen=QueueLength(queue[i]);
			minQueueIndex=i;
		}
	}
	return minQueueIndex;
}

5.4 打印队列信息 PrintQueues

功能：打印4个队列的信息
实现：

/*打印4个队列*/
void PrintQueues()
{
	int i=0;
	for(;i<4;i++)
	{
		printf("%d 号窗口：",i+1);
		QueueTraverse(queue[i]);
	}
}

5.5 销毁数据结构 DestoryDataStruct

功能：销毁数据结构，程序运行完毕，务必销毁数据结构，释放手动申请的内存空间
实现：

/*销毁链表和队列*/
void DestoryDataStruct()
{
	int i=0;
	DestroyList(&eventList);
	for(;i<4;i++)
	{
		DestroyQueue(&queue[i]);
	}
}

5.6 休眠函数 sleep

功能：程序休眠（暂停）一段时间。这个函数不是必要的。本示例在循环中加上，纯粹是为了更加清楚的在控制台观察程序运行过程
实现：

//休眠函数
void sleep(float time)
{
   clock_t   now   =   clock(); 
   while( clock() - now < time*1000); 
}

6. 编码全过程

为了项目的清晰，将单链表和队列的实现方法单独存放两个文件中。

6.1 数据结构头文件

  首先新建一个数据结构的头文件 DataStruct.h，其中包含有序单链表和队列的元素、结点、结构定义。

/*队列*/
#define TRUE  1
#define FALSE 0
#define OK    1
#define ERROR 0

typedef  int Status;

/* 以下是队列Queue的结构和基本操作 的声明*/
typedef struct {
	 int number;	   //编号，标识客户
	 int arrivalTime;  //客户到达时间
	 int duration;	   //办理事务时间
} QElemType;		   //队列的元素类型

typedef struct QNode{
	QElemType data;	   
	struct QNode * next;
} QNode;			   //队列的结点类型

typedef struct {
	QNode * front;	   //队头指针
	QNode * rear;	   //队尾指针
	int length;		   //队列长度
}LinkQueue;			   //定义一个链式队列

Status InitQueue(LinkQueue * queue);			/*初始化队列,申请一个头结点的内存*/
void DestroyQueue(LinkQueue * queue);			/*销毁队列*/
Status ClearQueue(LinkQueue * queue);			//将队列queue清空
Status QueueEmpty(LinkQueue queue);				//判断队列是否为空
Status GetHead(LinkQueue queue ,QElemType * e); //获取队列第一个元素
int QueueLength(LinkQueue queue);				//返回队列长度
Status EnQueue(LinkQueue * queue, QElemType e);	//元素e 插入队列queue
Status DeQueue(LinkQueue * queue ,QElemType * e);  //若队列queue不空，则删除Q的队头元素，用e返回其值，并返回 OK；否则返回ERROR
Status QueueTraverse(LinkQueue queue);			//遍历队列，对队列的每个元素调用Visit函数



/*以下为单链表的结构和基本操作 的声明*/
typedef struct Event{
	int occurTime;	  //事件发生时刻
	int nType;		  //事件类型，0：到达事件；1到4表示四个窗口的离开事件;
	
}Event,ElemType;	  //单链表的结点：事件

typedef struct LNode{
	ElemType data;		  //单链表的事件(即单链表的元素)
	struct LNode * next;  //下一个结点指针
}LNode;			 //单链表的结点

typedef struct {
	LNode * head;		//头指针
	LNode * rear;		//尾指针
	int length;			//链表长度
}LinkList;				//单链表结构

Status InitList(LinkList * L);						//初始化单链表
void DestroyList(LinkList * L);					//销毁单链表
Status ListInsertByOrder(LinkList * L, Event e);    //将事件e（链表的元素)的发生时间顺序插入到链表中
Status ListEmpty(LinkList  L);						//判断链表是否为空，空返回TRUE,否则返回FALSE;
Status ListDelFstNode(LinkList * L, Event * e);		//从链表中删除首结点，并将结点中的元素（事件）使用 e 返回
Status ListTraverse(LinkList  L);					//遍历链表

6.2 队列函数文件

  第二步，新建队列基本操作的文件 LinkQueue.c。

#include <stdio.h>
#include <stdlib.h>
#include "DataStruct.h"

/*初始化队列,申请一个头结点的内存*/
Status InitQueue(LinkQueue * queue)
{
	queue->front=(QNode *) malloc(sizeof(QNode));
	if(queue->front == NULL)
		exit(0);
	queue->front->next = NULL;
	queue->rear = queue->front;
	queue->length = 0;
	return OK;
}

/*销毁队列*/
void DestroyQueue(LinkQueue * queue)
{
	ClearQueue(queue);
	free(queue->front);
	queue->rear=queue->front=NULL;
}

 /* 将队列queue清空*/
Status ClearQueue(LinkQueue * queue)
{
	QNode * curNode;
	while((curNode= queue->front->next)!=NULL)
	{
		queue->front->next = curNode->next;
		free(curNode);
	}
	queue->rear=queue->front;
	queue->length=0;
	return OK;
}
//判断队列是否为空
Status QueueEmpty(LinkQueue queue)
{
	return queue.front == queue.rear? TRUE:FALSE;
}

 //获取队列第一个元素
Status GetHead(LinkQueue queue, QElemType * e)
{
	if(queue.length==0)
		return FALSE;
	*e=queue.front->next->data;
	return TRUE;
}

int QueueLength(LinkQueue queue)
{
	return queue.length;
}

//元素e 插入队列queue
Status EnQueue(LinkQueue * queue, QElemType e)
{
	QNode * curNode;
	curNode=(QNode *)malloc(sizeof(QNode));
	if(curNode == NULL)
	{
		printf("申请空间失败");
		exit(0);
	}
	curNode->data = e ;
	curNode->next = NULL;
	queue->rear->next = curNode;
	queue->rear = curNode;
	queue->length++;
	return TRUE;
}

//若队列queue不空，则删除Q的队头元素，用e返回其值，并返回 OK；否则返回ERROR
Status DeQueue(LinkQueue * queue ,QElemType * e)
{
	QNode * firstNode;
	if(queue->length == 0)
		return FALSE;
	firstNode=queue->front->next;
	*e=firstNode->data;
	queue->front->next=firstNode->next;
	free(firstNode);
	if(--queue->length==0)
		queue->rear=queue->front;
	return TRUE;
}
//队列遍历
Status QueueTraverse(LinkQueue queue)
{
	QNode * curNode;
	if(queue.length==0)
	{
		printf("队列为空\n");
		return FALSE;
	}
	curNode=queue.front->next;
	while(curNode)
	{
		printf("(编号:%d,达到时间:%d,持续时间:%d) ",curNode->data.number,curNode->data.arrivalTime,curNode->data.duration);
		curNode=curNode->next;
	}
	printf("\n");
	return TRUE;
}

6.3 有序链表函数文件

  第三步，新建有序单链表基本操作函数的文件 LinkList.c。

#include <stdio.h>
#include <stdlib.h>
#include "DataStruct.h"

 /*初始化单链表*/
Status InitList(LinkList * list)
{
	list->head=(LNode*) malloc(sizeof(LNode));
	if(list->head == NULL)
		exit(0);
	list->head->next = NULL;
	list->rear=list->head;
	list->length=0;
	return TRUE;
}

 /* 销毁单链表 */
void DestroyList(LinkList * list)
{
	LNode * curNode, * tempNode;
	curNode= list->head->next;
	while(curNode)
	{
		tempNode=curNode;
		curNode=curNode->next;
		free(tempNode);
	}
	free(list->head); //释放头结点
	list->head = list->rear = NULL;
	list->length = 0;
}


/* 将事件e（链表的元素)的发生时间顺序插入到链表中*/
Status ListInsertByOrder(LinkList * list, Event e)
{
	LNode * newNode,*curNode;
	newNode=(LNode *) malloc(sizeof(LNode));
	if(newNode == NULL)
		exit(0);
	newNode->data = e;
	
	if(list->length==0)			//链表为空
	{
		list->rear = list->head->next = newNode;
		newNode->next = NULL;

	}else						//链表不为空，需要循环找到插入位置
	{
		curNode=list->head;
		while(curNode->next != NULL && curNode->next->data.occurTime < e.occurTime) //遍历链表，找到e的合理位置
			curNode=curNode->next;

		if(curNode->next ==NULL) //在链表尾部
			list->rear=newNode;

		newNode->next = curNode->next;
		curNode->next = newNode;
	}
	list -> length++;
	return TRUE;

}

/*判断链表是否为空，空返回TRUE,否则返回FALSE;*/
Status ListEmpty(LinkList  list)
{
	return list.length == 0? TRUE:FALSE;
}

 /*从链表中删除首结点，并将第一个结点使用 node返回 */
Status ListDelFstNode(LinkList * list, Event * e)
{
	LNode * fstNode =list->head->next; //获取第一个结点
	if(ListEmpty(*list))
		return FALSE;
	*e= fstNode->data;
	list->head->next = fstNode->next;
	list->length--;
	if(list->length==0) //如果删除的结点是最后一个结点
		list->rear=list->head;
	free(fstNode);
	return TRUE;
}

/* 遍历链表 */
Status ListTraverse(LinkList  list)
{

	LNode * curNode=list.head->next;
	if(list.length==0){
		printf("链表为空\n");
		return ERROR;
	}
	while(curNode)
	{
		printf("(发生时刻:%d,事件类型:%d),",curNode->data.occurTime,curNode->data.nType);
		curNode = curNode->next;
	}

	return OK;
}

6.4 新建主程序文件

   最后一步，新建银行业务模拟的主程序

#include <stdio.h>
#include <time.h>
#include "DataStruct.h"

int CustomerNumber = 0;	//顾客的编号
int CloseTime = 50 ;	//银行关闭时间,即营业时间长度
int TotalTime = 0;		//所有客户总耗时
LinkQueue queue[4];		//4个队列模拟四个窗口
LinkList  eventList;	//事件链表

/*新建一个客户信息的元素（队列的元素）*/
QElemType NewCustomer(int number, int arrivalTime,int duration);
/*新建一个事件（单链表结点中的数据）*/
ElemType NewEvent(int occurTime,int nType);
/*在队列数组中查找长度最短的队列，并返回其下标*/
int ShortestQueueIndex();
/*打印4个队列*/
void PrintQueues();
//休眠函数
void sleep(float time);
/*销毁链表和队列*/
void DestoryDataStruct();


/*下面4个函数为核心函数*/
/*银行开门营业*/
void OpenForDay();
/*客户到达事件*/
void CustomerArrived(Event en);
/*客户离开*/
void CustomerDeparture(Event en);
/*银行模拟程序*/
void BankSimulation();


/*新建一个客户信息的元素（队列的元素）*/
QElemType NewCustomer(int number, int arrivalTime,int duration)
{
	QElemType e;
	e.number=number;
	e.arrivalTime=arrivalTime;
	e.duration=duration;
	return e;
}

/*新建一个事件（单链表结点中的数据）*/
ElemType NewEvent(int occurTime,int nType)
{
	Event e;
	e.occurTime=occurTime;
	e.nType=nType;
	return e;
}

/*在队列数组中查找长度最短的队列，并返回其下标*/
int ShortestQueueIndex()
{
	int i,minQueueIndex=0;			 //minQueueIndex 最短队列下标
	int minLen=QueueLength(queue[0]);//定义一个最小长度变量
	for(i=1;i<4;i++)
	{
		if(minLen>QueueLength(queue[i])){
			minLen=QueueLength(queue[i]);
			minQueueIndex=i;
		}
	}
	return minQueueIndex;
}

/*打印4个队列*/
void PrintQueues()
{
	int i=0;
	for(;i<4;i++)
	{
		printf("%d 号窗口：",i+1);
		QueueTraverse(queue[i]);
	}
}
//休眠函数
void sleep(float time)
{
   clock_t   now   =   clock(); 
   while( clock() - now < time*1000); 
}

/*销毁链表和队列*/
void DestoryDataStruct()
{
	int i=0;
	DestroyList(&eventList);
	for(;i<4;i++)
	{
		DestroyQueue(&queue[i]);
	}
}

/*银行开门营业，有以下几个功能：
	1. 初始化事件链表，并生成第一个客户到达事件插入链表
	2. 初始化4个队列，用于模拟银行窗口。
*/
void OpenForDay()
{
	int i;
	InitList(&eventList);
	ListInsertByOrder(&eventList, NewEvent(0,0));
	for(i=0;i<4;i++)
		InitQueue(&queue[i]);
}



/*	客户到达事件，主要有以下功能
	1. 生成一个新的客户到达事件，插入到事件链表中
	2. 将事件en中的刚到达客户信息插入到最短的队列中；
	3. 如果队列 插入前是空队列，则生成一个离开事件插入到事件链表中（空队列，说明客户到队列中，业务就立马办理了，无需等待)
*/
void CustomerArrived(Event en)
{	
	int i,duration;	//duration当前到达事件中的客户办理业务的持续时间
	int interTime_newCustomer;   // 新生成客户达到的间隔时间；
	int arrivalTime_newCustomer; //新生成客户的到达事件
	interTime_newCustomer = rand()%5 + 1;//新生成客户到达时间设置5分钟之内
	duration = rand()%30 + 1;			 //当前到达客户业务办理时间在30分钟
	arrivalTime_newCustomer = en.occurTime+interTime_newCustomer ;
	printf("时刻 %d: %d号 客户到达;\n",en.occurTime,++CustomerNumber);
	if(arrivalTime_newCustomer < CloseTime)
	ListInsertByOrder(&eventList,NewEvent(arrivalTime_newCustomer,0)); //生成一个新的客户到达事件插入到事件链表中

	i=ShortestQueueIndex();
	EnQueue(&queue[i],NewCustomer(CustomerNumber,en.occurTime,duration)); //到达客户入列
	if(QueueLength(queue[i])==1)//插入之前是空队列
		ListInsertByOrder(&eventList,NewEvent(en.occurTime+duration,i+1));//生成一个离开事件插入到事件链表中
}

/*客户离开*/
void CustomerDeparture(Event en)
{
	int i=en.nType-1;
	QElemType customer;
	DeQueue(&queue[i],&customer);
	printf("时刻 %d: %d号 客户离开;\n",en.occurTime,customer.number);
	TotalTime += en.occurTime - customer.arrivalTime;
	if(!QueueEmpty(queue[i])){
		GetHead(queue[i],&customer); //从队列中获取下一个客户
		ListInsertByOrder(&eventList,NewEvent(en.occurTime+customer.duration,i+1));//下个客户的离开事件插入事件链表
	}
		
}

void BankSimulation(){
	Event e;
	srand((unsigned)time(NULL));//使用时间生成一个随机种子
	OpenForDay();
	while(!ListEmpty(eventList))
	{
		ListDelFstNode(&eventList, &e);
		if(e.nType==0)
			CustomerArrived(e);
		else 
			CustomerDeparture(e);

		/*下面几行就是打印当前链表和队列*/
		printf("\n事件链表： ");
		ListTraverse(eventList);
		printf("\n\n");
		PrintQueues();
		printf("\n\n");
		sleep(1);//休眠1秒,可以注释掉
	}
	printf("每个客户平均时间:%f",(float)TotalTime/CustomerNumber);
	DestoryDataStruct();//最后销毁链表和数据结构，释放内存空间
}


int main()
{
	BankSimulation();
	getchar();
	return 0;
}

7. 运行结果

在这里插入图片描述

8. 小结

银行业务模拟项目，很好的复习了单链表和队列的使用，并能够对事件驱动模拟有一个很好的理解。

伯恩bourne
关注
  • 27
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构队列应用银行排队算法（离散事件模拟）
weixin_63785984的博客
11-20 1211
数据结构队列应用银行排队算法（离散事件模拟）
数据结构和算法（C语言）
java_newstu的博客
07-19 734
定义数据结构 = 个体的存储 +个体关系的存储（研究数据的存储）算法 = 对存储数据的操作 （对数据的操作）衡量算法的标准时间复杂度大概程序要执行的次数，而非执行的时间空间复杂度算法执行过程中大概所占用的最大内存难易程度健壮性预备知识指针指针就是地址 地址就是指针指针变量是存放内存单元地址的变量指针的本质是一个操作受限的非负整数一个字节就是一个地址，比方说一个double型的变量有8个字节，那么指针当中存了8个地址吗？不是，一般是存了这8个地址当中的首地址。地址。
栈和队列-数据结构与算法(C语言版)
monkeylvjava
05-17 812
栈和队列 一、栈 1. 概述 栈是限定仅在表尾进行插入和删除操作的线性表。进行插入或删除操作的一端叫做栈顶，另一端称为栈底，没有数据元素的栈称为空栈，插入数据元素的操作称为入栈，删除数据元素的操作称为出栈。 栈的特性：**先进后出（FILO）**或者 后进先出（LIFO）。 栈的存储结构 顺序栈（顺序存储） 采用顺序存储结构模拟栈存储数据，因为每次分配固定大小的存储空间，操作不当可能产生上溢或者下溢。 链栈（链式存储） 采用链式存储结构实现 两种实现方式的区别，仅限于数据元素在实际物
C语言数据结构篇---------------表
qq_66337990的博客
08-10 148
首先定义了一个结构体 list_t 用来表示顺序表，其中包含了最大长度、当前元素个数以及存储节点数据的数组成员。在 main 函数中，首先通过 create_list 函数创建了一个有25个元素空间的顺序表，然后使用 insert_list 函数在表的头部插入了一些数据，最后调用 show_list 函数显示了表的内容。的作用是定义类型别名，可以将复杂或冗长的类型名简化为一个更易读的别名，使代码更加清晰和易于理解。执行的频度: 算法中 语句执行的次数 与 输入问题规模的 比值。//静态分配数组长度。
【数据结构】（五）（循环）队列，链式队列（银行排队（离散事件模拟）算法）
qq_51523386的博客
04-09 1898
【数据结构】（五）队列，链式队列（银行排队算法） （一）队列：（如果用循环将使算法时间变得复杂，所以为了提高运算效率，引入队列） （1）假溢出：（为了解决假溢出，引入循环队列） （2）循环队列：（判断空满条件） 其中方法二： （3）队列的创建：（所有的引用修改都是为了可以传出去而使用的） C++： C语言： （4）操作： 入队： 出队： 在主函数中输出item: 改为C++中语句： 读取对头元素： （二）链式队列： C++： （2）区别： （三）银行排队（离散事件模拟）
c语言窗口事件,C语言数据结构之离散事件模拟的实现代码（银行排队事件）
weixin_34345947的博客
05-18 345
C语言数据结构之离散事件模拟的实现代码(银行排队事件)C语言数据结构之离散事件模拟的实现代码(银行排队事件)结果：IDE：Visual Studio 2019声明：为了方便书写代码，用到了C++的引用调用特性和iostream作为输入输出，读者可以使用指针调用和scanf_s/print语句实现相同效果tips：有疑问可以在下面交流，我会尽量回复的头文件heads.h#pragma once#in...
数据结构与算法的学习小结与个人的见解(c语言）
qq_62916408的博客
06-13 422
数据结构与算法的学习小结与个人的见解(c语言）
队列应用：银行排队模拟(离散事件模拟)
m0_63223213的博客
07-07 4346
假设某银行有四个窗口对外接待客户，从银行开门到关门之前起不断有客户进入银行。由于每个窗口只能接待一个客户，因此在客户人数众多时需在每个窗口前顺次排队，对于刚进入银行的客户，如果某个窗口的业务员正在空闲，则可上前办理业务，反之，若四个窗口均有客户所占，他便会排在队伍最短的队伍后面。假设事件表中最早发生的事件是新客户到达，则随之应得到两个时间（均由随机生成数函数得到）：（1）是本客户办理业务所需时间（2）是下一个客户将到达银行的时间间隔。现在，需要编制一个程序以模拟银行的这种业务活动并求出一天中客户在银行逗留的
离散事件模拟（Discrete Event Simulation，简称DES）
m0_64357419的博客
08-23 2235
通过这个示例，你可以更好地理解离散事件模拟的基本原理和实际应用，以及如何使用Python来实现这一方法，帮助我们研究和优化复杂系统的行为和性能。虽然离散事件模拟具有广泛的应用前景，但在应用时需要谨慎选择模型、设定参数，并进行适当的验证和敏感性分析，以确保模拟结果的准确性和可靠性。离散事件模拟的核心思想是模拟系统在离散的时间点上发生的事件，这些事件会引起系统状态的变化。离散事件模拟是一种强大的计算机模拟方法，用于研究和分析系统在离散时间点上发生的事件和互动。根据模型中设定的规则，生成即将发生的事件。
清华大学出版社《数据结构(C语言版)》部分结构与算法C语言实现源码
11-20
第三章 - 链队列、循环队列、栈、栈链、离散时间模拟 第五章 - 广义表 第六章 - 二叉树链式存储、二叉树顺序存储、哈夫曼树与哈夫曼编码、树孩子表示法、树孩子兄弟表示法、树双亲表示法 第七章 - 图数组表示法、图...
【视觉SLAM】 十四讲ch5习题
weixin_68880273的博客
07-18 1106
介绍了《视觉SLAM十四讲》的ch5习题
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 330
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
基于JSP的高校信息资源共享平台
最新发布
heye0910032的博客
07-22 469
高校信息资源共享平台的开发和实现，为高校信息资源的管理和共享提供了一个有效的解决方案。通过使用JSP技术和MySQL数据库，本系统实现了一个稳定、安全、易用的高校信息资源管理平台。虽然在开发过程中遇到了一些技术挑战，但通过不断学习和实践，最终完成了一个能够满足用户需求的系统。未来，我们将继续优化系统功能，提升用户体验，以期达到更高的应用价值和社会效益。高校信息资源共享平台的开发和实现，为高校信息资源的管理和共享提供了一个有效的解决方案。
Linux -软件安装
z2331198564653的博客
07-18 882
项目开发好需要部署，而项目本身可能依赖其他软件。这时在部署项目时就需要安装依赖的软件。比如: jdk mysql tomcat redis rabbitmq es等。
MySQL（事务、索引）&&MyBatis
hycccccch的博客
07-19 705
事务指的是一组操作的集合，是一个不可分割的工作单位。事务会将所有的操作作为一个整体一起向系统提交或撤销操作请求，即这些操作要么同时成功，要么同时失败默认MySQL的事务是自动提交，即当执行一条DML语句时，MySQL会立即隐式的提交事务开启事务后运行事务不会对数据改变，commit后才会改变数据如果有命令发生错误，需要进行rollback进行回滚、
PostgreSQL的逻辑架构
weixin_41992498的博客
07-18 139
一、PostgreSql的逻辑架构：所有者：
Spring框架之DI依赖注入
G81948577的博客
07-18 996
我们在下面构建spring的过程中体会依赖注入；从上面的图中我们知道，在ssm框架中服务层（server）无法直接操作数据库，持久层（dao）是直接操作数据库进行数据处理的，但是我们如果在服务层有一个持久层的对象，然后我们在服务层通过对象去调用持久层的方法就可以操作数据库了。@OverrideSystem.out.println("持久层，你好");UserServiceImpl类中的代码如下@Override。
数据结构C语言版-算法与信息处理
主要基于C语言，引用了严蔚敏、吴伟民合著的《数据结构(C语言版)》作为教材，并提供了其他几本参考书籍，包括《数据结构》、《数据结构与算法分析》、《数据结构习题与解析(C语言版)》以及《数据结构与算法》。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值