数据结构学习——队列（链队列、循环队列）

发布时间：2023-04-19 18:30

文章目录

  • 前言——队列
  • 一、链队列
    • 1.构建结构体
    • 2.创建一个队列
    • 3.跳出队列
    • 4.进入队列
    • 5.出队列
    • 6.样例测试
    • 7.完整代码
    • 8.结果
  • 二、循环队列
    • 1.构造结构体
    • 2.创造循环队列
    • 3.进入队列
    • 4.出队列
    • 5.测试
    • 6.完整代码
    • 7.测试结果

前言——队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
\"数据结构学习——队列（链队列、循环队列）_第1张图片\"

一、链队列

1.构建结构体

typedef struct LinkNode
{
	int data;
	struct LinkNode* next;
}*LinkNodePtr;

typedef struct LinkQueue
{
	LinkNodePtr front;
	LinkNodePtr rear;
}*LinkQueuePtr;

2.创建一个队列

LinkQueuePtr initQueue()
{
	LinkQueuePtr resultPtr; 
	resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));

	LinkNodePtr headerPtr;
	headerPtr = (LinkNodePtr)malloc(sizeof(LinkNodePtr));
	
	headerPtr->next = NULL;
	
	resultPtr->front = headerPtr;
	resultPtr->rear = headerPtr;
	
	return resultPtr;
}

3.跳出队列

void outputLinkQueue(LinkQueuePtr paraQueuePtr)
{
	LinkNodePtr tempPtr; 
	tempPtr = paraQueuePtr->front->next;
	while (tempPtr != NULL) 
	{
		printf(\"%d \", tempPtr->data);
		tempPtr = tempPtr->next;
	}
	printf(\"\\r\\n\");
}

4.进入队列

void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) 
{

	LinkNodePtr tempNodePtr;
	 
	tempNodePtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
	
	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;
	
	paraQueuePtr->rear->next = tempNodePtr;
	
	paraQueuePtr->rear = tempNodePtr;
}

5.出队列

int dequeue(LinkQueuePtr paraQueuePtr) 
{
	int resultValue;
	
	LinkNodePtr tempNodePtr;

	if (paraQueuePtr->front == paraQueuePtr->rear) 
	{
		printf(\"此队列为空.\\r\\n\");
		return -1;
	}

	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = paraQueuePtr->front->next->next;

	if (paraQueuePtr->rear == tempNodePtr) 
	{
		paraQueuePtr->rear = paraQueuePtr->front;
	}
	
	tempNodePtr = NULL;

	return resultValue;
}

6.样例测试

void testLinkQueue()
{
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr, 20);
	enqueue(tempQueuePtr, 40);
	enqueue(tempQueuePtr, 60);
	enqueue(tempQueuePtr, 80);
	enqueue(tempQueuePtr, 100);

	outputLinkQueue(tempQueuePtr);

	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));

	enqueue(tempQueuePtr, 15);
	outputLinkQueue(tempQueuePtr);
}

7.完整代码

#include 
#include 


typedef struct LinkNode
{
	int data;
	struct LinkNode* next;
}*LinkNodePtr;

typedef struct LinkQueue
{
	LinkNodePtr front;
	LinkNodePtr rear;
}*LinkQueuePtr;

LinkQueuePtr initQueue()
{
	LinkQueuePtr resultPtr; 
	resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));

	LinkNodePtr headerPtr;
	headerPtr = (LinkNodePtr)malloc(sizeof(LinkNodePtr));
	
	headerPtr->next = NULL;
	
	resultPtr->front = headerPtr;
	resultPtr->rear = headerPtr;
	
	return resultPtr;
}

void outputLinkQueue(LinkQueuePtr paraQueuePtr)
{
	LinkNodePtr tempPtr; 
	tempPtr = paraQueuePtr->front->next;
	while (tempPtr != NULL) 
	{
		printf(\"%d \", tempPtr->data);
		tempPtr = tempPtr->next;
	}
	printf(\"\\r\\n\");
}

void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) 
{

	LinkNodePtr tempNodePtr;
	 
	tempNodePtr = (LinkNodePtr)malloc(sizeof(struct LinkNode));
	
	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;
	
	paraQueuePtr->rear->next = tempNodePtr;
	
	paraQueuePtr->rear = tempNodePtr;
}

int dequeue(LinkQueuePtr paraQueuePtr) 
{
	int resultValue;
	
	LinkNodePtr tempNodePtr;

	if (paraQueuePtr->front == paraQueuePtr->rear) 
	{
		printf(\"此队列为空.\\r\\n\");
		return -1;
	}

	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = paraQueuePtr->front->next->next;

	if (paraQueuePtr->rear == tempNodePtr) 
	{
		paraQueuePtr->rear = paraQueuePtr->front;
	}
	
	tempNodePtr = NULL;

	return resultValue;
}

void testLinkQueue()
{
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr, 20);
	enqueue(tempQueuePtr, 40);
	enqueue(tempQueuePtr, 60);
	enqueue(tempQueuePtr, 80);
	enqueue(tempQueuePtr, 100);

	outputLinkQueue(tempQueuePtr);

	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));
	printf(\"dequeue gets %d\\r\\n\", dequeue(tempQueuePtr));

	enqueue(tempQueuePtr, 15);
	outputLinkQueue(tempQueuePtr);
}

int main()
{
	testLinkQueue();
	return 1;
}

8.结果

\"数据结构学习——队列（链队列、循环队列）_第2张图片\"

二、循环队列

循环队列就是将队列存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。在循环队列结构中，当存储空间的最后一个位置已被使用而再要进入队运算时，只需要存储空间的第一个位置空闲，便可将元素加入到第一个位置，即将存储空间的第一个位置作为队尾。 循环队列可以更简单防止伪溢出的发生，但队列大小是固定的。
\"数据结构学习——队列（链队列、循环队列）_第3张图片\"

1.构造结构体

typedef struct CircleIntQueue
{
	int data[TOTAL_SPACE];
 
	int head;
 
	int tail;
}*CircleIntQueuePtr;

2.创造循环队列

CircleIntQueuePtr initQueue() 
{
	CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue));
	resultPtr->head = 0;
	resultPtr->tail = 0;
 
	return resultPtr;
}

3.进入队列

void enqueue(CircleIntQueuePtr paraPtr, int paraValue) 
{
	if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head) 
	{
		printf(\"队列已满.\\r\\n\");
		return;
	} 
 
	paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
	paraPtr->tail++;
}

4.出队列

int dequeue(CircleIntQueuePtr paraPtr) 
{
	int resultValue;
	if (paraPtr->head == paraPtr->tail) 
	{
		printf(\"队列无元素.\\r\\n\");
		return -1;
	}
 
	resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
	paraPtr->head++;
 
	return resultValue;
}

5.测试

void outputLinkQueue(CircleIntQueuePtr paraPtr)
{
	int i;
	if (paraPtr->head == paraPtr->tail) 
	{
		printf(\"队列为空.\");
		return;
	}
 
	printf(\"队列中的元素: \");
	for (i = paraPtr->head; i < paraPtr->tail; i++) 
	{
		printf(\"%d \", paraPtr->data[i % TOTAL_SPACE]);
		if(i<paraPtr->tail-1)
		{
			printf(\",\");
		}
	}
 
	printf(\"\\r\\n\");
}

void testLinkQueue()
{
	int i;
	CircleIntQueuePtr tempPtr = initQueue();
	for (i=5;i < 12;i ++) 
	{
		enqueue(tempPtr, i);
	}
 
	outputLinkQueue(tempPtr);
 
	for (i = 0; i < 8; i ++) 
	{
		printf(\"dequeue gets %d\\r\\n\", dequeue(tempPtr));
	}
 
	enqueue(tempPtr, 8);
	outputLinkQueue(tempPtr);
}

6.完整代码

#include 
#include 
 
#define TOTAL_SPACE 5
 
typedef struct CircleIntQueue
{
	int data[TOTAL_SPACE];
 
	int head;
 
	int tail;
}*CircleIntQueuePtr;

CircleIntQueuePtr initQueue() 
{
	CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue));
	resultPtr->head = 0;
	resultPtr->tail = 0;
 
	return resultPtr;
}

void enqueue(CircleIntQueuePtr paraPtr, int paraValue) 
{
	if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head) 
	{
		printf(\"队列已满.\\r\\n\");
		return;
	} 
 
	paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
	paraPtr->tail++;
}

int dequeue(CircleIntQueuePtr paraPtr) 
{
	int resultValue;
	if (paraPtr->head == paraPtr->tail) 
	{
		printf(\"队列无元素.\\r\\n\");
		return -1;
	}
 
	resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
	paraPtr->head++;
 
	return resultValue;
}

void outputLinkQueue(CircleIntQueuePtr paraPtr)
{
	int i;
	if (paraPtr->head == paraPtr->tail) 
	{
		printf(\"队列为空.\");
		return;
	}
 
	printf(\"队列中的元素: \");
	for (i = paraPtr->head; i < paraPtr->tail; i++) 
	{
		printf(\"%d \", paraPtr->data[i % TOTAL_SPACE]);
		if(i<paraPtr->tail-1)
		{
			printf(\",\");
		}
	}
 
	printf(\"\\r\\n\");
}

void testLinkQueue()
{
	int i;
	CircleIntQueuePtr tempPtr = initQueue();
	for (i=5;i < 12;i ++) 
	{
		enqueue(tempPtr, i);
	}
 
	outputLinkQueue(tempPtr);
 
	for (i = 0; i < 8; i ++) 
	{
		printf(\"dequeue gets %d\\r\\n\", dequeue(tempPtr));
	}
 
	enqueue(tempPtr, 8);
	outputLinkQueue(tempPtr);
}

int main(){
	testLinkQueue();
	return 1;
}

7.测试结果

\"数据结构学习——队列（链队列、循环队列）_第4张图片\"

相关推荐

完整后端开发流程

干货丨Kotlin在Spring Boot中的应用

Windows下安装Bun像Node或Deno的现代JS运行时

记录js逆向5秒dun的日子

axios源码解析 - 请求拦截器

Spring开发社交模块小记

设计模式 - 单例设计模式

《区块链学习笔记》ETH-智能合约（上）

揭开SSL的神秘面纱，了解如何用SSL保护数据

钱岭：别担心“35岁危机”，要成为“老专家”

SpringCloud：网关gateway（单点登录）

GAN能进行股票预测吗？

Topic 10. 单因素 Logistic 回归分析—单因素分析表格

免费SSL证书申请及部署实践

动手学数据分析记录

深度学习-数据增强总结

c#生成静态库_c#生成的exe文件加密

Java Agent 踩坑之 appendToSystemClassLoaderSearch 问题

Vue3中响应式原理reactive模拟实现

基于改进的K-means算法在共享交通行业客户细分中的应用

ItVuer - 免责声明 - 关于我们 - 联系我们

本网站信息来源于互联网，如有侵权请联系：561261067@qq.com

桂ICP备16001015号