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

发布时间：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张图片\"

相关推荐

Kubernetes基础

kotlin之MQTT协议实现

pybind11用python调用C++代码

mysql 删除的三种方法_数据库三种删除方法： delete drop truncate

ArrayDeque（JDK双端队列）源码深度剖析

后疫情时代，看海淀区如何实现考试考务工作的数字化转型

我为了跳槽，熬夜5天整理了一份Java面试八股文，有需要的，拿走不谢

如何为Github开源项目提交PR完整版

Python Decorator的设计模式演绎过程解析

C++中list的使用与模拟实现

二叉树的逐层遍历--java实现

『HarmonyOS』探索HarmonyOS应用

【史上最全MYSQL总结】MySQL超详细笔记

【超详细】pytorch安装及配置

【无标题】黑炫酷的监控界面，实际上是用了什么开源工具？

这年头谁还用POI，快来使用国人写的EasyExcel吧，SpringBoot＋EasyExcel的快速入门

html 函数 this,关于JavaScript中的this指向问题总结篇

form表单提交数据如何拿到返回值

2022最新慕课网课程大全_完整无密_百度网盘分享

Windows 进程的创建和终止

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

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

桂ICP备16001015号