【数据结构】栈和队列

已于 2024-05-13 10:27:46 修改
阅读量1.1k 收藏 30
点赞数 25
分类专栏： 数据结构 文章标签： 数据结构 栈 队列 链表 数组
于 2024-05-12 21:01:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81577798/article/details/138763651
版权

目录

1.栈

栈的概念模型：

先进后出规律模型：  ​编辑

栈的应用： 

栈的实现 

栈创建分析： 

 我们需要实现的功能接口如下：

 栈的初始化

栈的入栈 

栈的出栈 

 查看栈顶元素

 计算栈的元素个数

 判空

 栈的销毁

 栈整个代码实现和测试文件：

 Stack.h

Stack.c 

Text.c 

 2.队列

 队列的概念模型：

​编辑 先进先出的规律：

 栈的应用：

队列的实现 

队列创建分析： 

数组实现：

链表实现： 

 我们需要实现的功能接口如下：

 队列的初始化

 队列的插入

 队列的删除

 获取队列头部元素

 获取队列队尾元素

 获取队列中有效元素个数

 检测队列是否为空，如果为空返回非零结果，如果非空返回0

 销毁队列

 队列整个代码实现和测试文件：

Queue.h 

Queue.c 

Text.c 

1.栈

栈是数据结构中的一种线性结构，栈的出入数据只能从一端进行，所以栈的出入规律是先进后出（FILO, First In Last Out )。

栈的概念模型：

先进后出规律模型：  

栈的应用： 

  •  算法上的递归应用
  •  游戏上的多开界面，比如打开背包之后，又可以打开装备属性的界面，但是这时候背包界面   却没有关闭。

栈的实现 

栈创建分析： 

栈是一种只有一端出口，并且先进后出的数据结构，实现方面我们可以通过数组或者链表进行实现，他们两种实现各有优劣，小编这边使用的是数组实现，当然为了更加动态的表示栈，我们这边使用动态数组实现。

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

// 类型声明
typedef int STDataType;


typedef struct Stack
{
	STDataType* a;	// 动态数组
	int top;		// 栈顶
	int capacity;	// 表示空间容量
}ST;

 我们需要实现的功能接口如下：

// 栈的初始化
void StackInit(ST* pst);

// 入栈
void StackPush(ST* pst, STDataType x);

// 出栈
void StackPop(ST* pst);

// 查看栈顶元素
STDataType StackTop(ST* pst);

// 计算栈的元素个数
int StackSize(ST* pst);

// 判空
bool StackEmpty(ST* pst);

// 栈的销毁
void StackDestory(ST* pst);

 栈的初始化

 我们这边实现栈的初始化有一个分歧，就是我们的top初始化什么？如果初始化为0，那么top代表的就是栈的元素个数，初始化为-1，那么top代表的就是动态数组的下标。

我这边为了方便后续判断栈的满我的top就初始化为0。 

代码实现： 

// 栈的初始化
void StackInit(ST* pst)
{
	// 判空
	assert(pst);

	// 初始化
	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

栈的入栈 

 栈为空时我们入栈的概念图，但是我们需要判断栈是否为满，如果满了就重新分配空间，没满就直接插入。

 代码实现： 

// 入栈
void StackPush(ST* pst, STDataType x)
{
	// 判空
	assert(pst);

	// 判栈的满
	// 我这边定义的top为0，所以代表的是数据的个数，当个数和容量相等时为满
	if (pst->top == pst->capacity)
	{
		// 三目操作符
		// 判断原空间是否为0，为0则先分配4个空间，不为0则开辟两倍空间。
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;

		// 动态分配空间
		STDataType* tmp = (STDataType*)malloc(newcapacity * sizeof(STDataType));
		// 判断是否申请成功
		if (NULL == tmp)
		{
			perror("StackPush()::malloc fail");
			return 1;
		}
			pst->a = tmp;
			pst->capacity = newcapacity;
	}

	// 入栈
	pst->a[pst->top] = x;
	pst->top++;
}

栈的出栈 

 栈的出栈实现很简单，我们只需要将top--就行了，这样动态输入就访问不到原栈顶元素了，但是我们还是需要注意如果栈内的元素为0，我们是不可以执行出栈操作的。

 代码实现： 

// 出栈
void StackPop(ST* pst)
{
	// 判空
	assert(pst);
	// 栈内数据不可以为0
	assert(pst->top > 0);

	// 出栈
	pst->top--;
}

 查看栈顶元素

每次查看栈顶元素需要我们访问最上层数据，在每次访问后需要记录下来返回，过程中top代表的是数据个数，返回下标需要减1。

 代码实现：

// 查看栈顶元素
STDataType StackTop(ST* pst)
{
	// 判空
	assert(pst);
	// 栈内数据不可以为0
	assert(pst->top > 0);

	return pst->a[pst->top - 1];
}

 计算栈的元素个数

由于我们前边的top定义是0，top代表的是栈内数据的个数，我们直接返回top即可。 

 代码实现：

// 计算栈的元素个数
int StackSize(ST* pst)
{
	// 判空
	assert(pst);

	return pst->top;
}

 判空

判空也很简单我们只需要验证top是否为0即可。 

  代码实现：

// 判空
bool StackEmpty(ST* pst)
{
	// 判空
	assert(pst);

	return pst->top == 0;
}

 栈的销毁

由于我们的栈内数据是由动态内存申请的，所以我们最后需要释放动态内存在堆区申请的空间，防止空间泄露。 

// 栈的销毁
void StackDestory(ST* pst)
{
	// 判空
	assert(pst);

	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}

 栈整个代码实现和测试文件：

 Stack.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

// 类型声明
typedef int STDataType;


typedef struct Stack
{
	STDataType* a;	// 动态数组
	int top;		// 栈顶
	int capacity;	// 表示空间容量
}ST;

// 栈的初始化
void StackInit(ST* pst);

// 栈的销毁
void StackDestory(ST* pst);

// 入栈
void StackPush(ST* pst, STDataType x);

// 出栈
void StackPop(ST* pst);

// 查看栈顶元素
STDataType StackTop(ST* pst);

// 计算栈的元素个数
int StackSize(ST* pst);

// 判空
bool StackEmpty(ST* pst);

Stack.c 

#include "Stack.h"

// 栈的初始化
void StackInit(ST* pst)
{
	// 判空
	assert(pst);

	// 初始化
	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

// 入栈
void StackPush(ST* pst, STDataType x)
{
	// 判空
	assert(pst);

	// 判栈的满
	// 我这边定义的top为0，所以代表的是数据的个数，当个数和容量相等时为满
	if (pst->top == pst->capacity)
	{
		// 三目操作符
		// 判断原空间是否为0，为0则先分配4个空间，不为0则开辟两倍空间。
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;

		// 动态分配空间
		STDataType* tmp = (STDataType*)malloc(newcapacity * sizeof(STDataType));
		// 判断是否申请成功
		if (NULL == tmp)
		{
			perror("StackPush()::malloc fail");
			return 1;
		}
			pst->a = tmp;
			pst->capacity = newcapacity;
	}

	// 入栈
	pst->a[pst->top] = x;
	pst->top++;
}

// 出栈
void StackPop(ST* pst)
{
	// 判空
	assert(pst);
	// 栈内数据不可以为0
	assert(pst->top > 0);

	// 出栈
	pst->top--;
}

// 查看栈顶元素
STDataType StackTop(ST* pst)
{
	// 判空
	assert(pst);
	// 栈内数据不可以为0
	assert(pst->top > 0);

	return pst->a[pst->top - 1];
}

// 计算栈的元素个数
int StackSize(ST* pst)
{
	// 判空
	assert(pst);

	return pst->top;
}

// 判空
bool StackEmpty(ST* pst)
{
	// 判空
	assert(pst);

	return pst->top == 0;
}

// 栈的销毁
void StackDestory(ST* pst)
{
	// 判空
	assert(pst);

	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}

Text.c 

#include "Stack.h"

int main()
{
	ST s1;

	// 栈的初始化
	StackInit(&s1);

	// 入栈
	StackPush(&s1, 1);
	StackPush(&s1, 2);
	StackPush(&s1, 3);
	StackPush(&s1, 4);

	// 出栈
	/*printf("%d ", StackTop(&s1));
	StackPop(&s1);
	printf("%d ", StackTop(&s1));
	StackPop(&s1);
	printf("%d ", StackTop(&s1));
	StackPop(&s1);
	printf("%d ", StackTop(&s1));*/
	// 报错
	/*StackPop(&s1);
	printf("%d ", StackTop(&s1));*/

	// 如果栈的元素不为0，则打印，然后删除
	/*while (!StackEmpty(&s1))
	{
		printf("%d ", StackTop(&s1));
		StackPop(&s1);
	}*/

	// 计算栈的元素个数
	int ret = StackSize(&s1);
	printf("栈的数据个数为：%d", ret);

	// 栈的销毁
	StackDestory(&s1);

	return 0;
}

 2.队列

 队列是数据结构中的一种线性结构，队列的出入数据只能从队尾进行，出数据只能从队首进行，所以队列的出入规律是先进先出（FIFO, First In First Out )。

 队列的概念模型：

 先进先出的规律：

队列的数据是由一端对尾进入，队首出去，所以是先进先出的规律。 

 栈的应用：

  • 我们平时点奶茶时会在小程序上获得一个排序号，这就是通过队列实现的。
  • 为了保证公平性的抽号机器 

队列的实现 

队列创建分析： 

同栈一样，队列也属于线性的数据结构，实现队列我们也可以通过数组或者链表来实现。 

数组实现：

找首位数据很容易，但是入队列和出队列都要对整体的数据进行挪动太过于麻烦。

链表实现： 

入队列和出队列十分方便，但是每次都需要找队尾，我们可以提前定义队尾指针解决这个问题。 

综上我决定使用链表实现队列。 

 队列节点：

 

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

// 类型声明
typedef int QDataType;

// 每个队列数据的节点创建
typedef struct QueueNode
{
	QDataType data;		// 存放数据
	struct QueueNode* next; // 指向下一个节点的指针
}QueueNode;

为了方便使用头尾指针我们创建一个存放头尾指针的结构体，同时也具有避免传二级指针的担忧,然后再定义一个size用于记录数据的个数。

// 存放头尾指针的结构体
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
    int size;
}Queue;

 我们需要实现的功能接口如下：

// 队列的初始化
void QueueInit(Queue* pq);

// 队列的插入
void QueuePush(Queue* pq, QDataType x);

// 队列的删除
void QueuePop(Queue* pq);

// 获取队列头部元素
QDataType QueueFront(Queue* pq);

// 获取队列队尾元素
QDataType QueueBack(Queue* pq);

// 获取队列中有效元素个数
int QueueSize(Queue* pq);

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* pq);

// 销毁队列
void QueueDestroy(Queue* pq);

 队列的初始化

 头尾指针指向NULL,将size定义为。

代码实现： 

// 队列的初始化
void QueueInit(Queue* pq)
{
	// 判空
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

 队列的插入

 代码实现：

// 队列的插入
void QueuePush(Queue* pq, QDataType x)
{
	// 判空
	assert(pq);

	// 插入
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (NULL == newnode)
	{
		perror("QueuePush()::malloc fail");
		return 1;
	}

	newnode->next = NULL;
	newnode->data = x;

	// head为空
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else {
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

 队列的删除

  代码实现：

void QueuePop(Queue* pq)
{
	// 判空
	assert(pq);
	assert(pq->head != NULL);

	// 删除
	// 只有一个节点
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else {
		Queue* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	pq->size--;
}

 获取队列头部元素

 代码实现：

QDataType QueueFront(Queue* pq)
{
	// 判空
	assert(pq);
	assert(pq->head != NULL);

	return pq->head->data;
}

 获取队列队尾元素

 代码实现：

QDataType QueueBack(Queue* pq)
{
	// 判空
	assert(pq);
	assert(pq->head != NULL);

	return pq->tail->data;
}

 获取队列中有效元素个数

 代码实现：

int QueueSize(Queue* pq)
{
	// 判空
	assert(pq);

	return pq->size;
}

 检测队列是否为空，如果为空返回非零结果，如果非空返回0

  代码实现：

bool QueueEmpty(Queue* pq)
{
	// 判空
	assert(pq);

	return pq->size == 0;
}

 销毁队列

 代码实现：

void QueueDestroy(Queue* pq)
{
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

 队列整个代码实现和测试文件：

Queue.h 

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

// 类型声明
typedef int QDataType;

// 每个队列数据的节点创建
typedef struct QueueNode
{
	QDataType data;		// 存放数据
	struct QueueNode* next; // 指向下一个节点的指针
}QueueNode;

// 存放头尾指针的结构体
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
	int size;
}Queue;

// 队列的初始化
void QueueInit(Queue* pq);

// 队列的插入
void QueuePush(Queue* pq, QDataType x);

// 队列的删除
void QueuePop(Queue* pq);

// 获取队列头部元素
QDataType QueueFront(Queue* pq);

// 获取队列队尾元素
QDataType QueueBack(Queue* pq);

// 获取队列中有效元素个数
int QueueSize(Queue* pq);

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* pq);

// 销毁队列
void QueueDestroy(Queue* pq);

Queue.c 

#include "Queue.h"

// 队列的初始化
void QueueInit(Queue* pq)
{
	// 判空
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

// 队列的插入
void QueuePush(Queue* pq, QDataType x)
{
	// 判空
	assert(pq);

	// 插入
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (NULL == newnode)
	{
		perror("QueuePush()::malloc fail");
		return 1;
	}

	newnode->next = NULL;
	newnode->data = x;

	// head为空
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else {
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

// 队列的删除
void QueuePop(Queue* pq)
{
	// 判空
	assert(pq);
	assert(pq->head != NULL);

	// 删除
	// 只有一个节点
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else {
		Queue* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	pq->size--;
}

// 获取队列头部元素
QDataType QueueFront(Queue* pq)
{
	// 判空
	assert(pq);
	assert(pq->head != NULL);

	return pq->head->data;
}

// 获取队列队尾元素
QDataType QueueBack(Queue* pq)
{
	// 判空
	assert(pq);
	assert(pq->head != NULL);

	return pq->tail->data;
}

// 获取队列中有效元素个数
int QueueSize(Queue* pq)
{
	// 判空
	assert(pq);

	return pq->size;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* pq)
{
	// 判空
	assert(pq);

	return pq->size == 0;
}

// 销毁队列
void QueueDestroy(Queue* pq)
{
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

Text.c 

#include "Queue.h"


int main()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);

	printf("%d ", QueueFront(&q));
	QueuePop(&q);

	QueuePush(&q, 3);
	QueuePush(&q, 4);

	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}

	QueueDestroy(&q);


	return 0;
}

 

阳区欠
关注
  • 25
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
数据结构——栈与队列
m0_57484470的博客
10-17 6106
数据结构栈与队列相关基础知识详解！！！
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
数据结构 栈和队列
qq_52847866的博客
06-15 3388
5. 访问效率：顺序存储结构的元素在内存中是连续存储的，对于 CPU 缓存等硬件有较好的利用效率，因此在访问速度上可能更快。特殊矩阵的压缩存储可以大幅减少存储空间的占用，提高存储效率，并在某些情况下加速矩阵的运算和操作。需要注意的是，多维数组的存储方式可能会影响程序的性能，特别是对于大型多维数组和对数组访问频繁的场景。总之，栈和队列都是重要的数据结构，在不同的应用场景中发挥着关键的作用。栈和队列都是常见的数据结构，可以使用不同的存储结构进行实现，包括顺序存储结构和链式存储结构。函数判断栈是否为空。
数据结构栈和队列
m0_65185254的博客
10-28 3958
数据结构作业
数据结构栈和队列的基本操作
lizhi20210729的博客
11-21 1415
前言 这一篇我就不附书上代码了，太慢。 线性表的应用 线性表的合并 int ListLength(LNode L) { int i=0; LinkList p; p=L.next; while(p) { i++; p=p->next; } return i; } void MergeList(LinkList LA,LNode LB) { int m,n,i,e; m=ListLength(*LA);n=ListLength(
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 1万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
[C/C++]数据结构 栈和队列
m0_74910646的博客
11-18 1113
是一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作,进行数据插入和删除操作的一端称为,另一端称为,栈中的数据元素遵守的原则.
数据结构之栈和队列
weixin_45699237的博客
02-19 2637
1、栈 1.1 概念 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈 顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据在栈顶。 ...
数据结构之栈与队列详解
Ruiren_的博客
01-20 1773
栈和队列是一种特殊的线性结构，他与之前学的线性结构不同，栈和队列是拥有一种特殊规则的线性结构，虽然它是用数组或者链表实现，但是只有符合这种规则才能被称作栈或者队列
Java数据结构之栈和队列
fear_wolf的博客
10-24 1012
我们可以从集合那一节的图中看出，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。我们可以采用头插法来入栈，每次出栈时删除的也是头节点，时间复杂度也是O（1），但仍没有顺序栈方便，毕竟顺序栈不用修改指向。：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有。，队不为空时，rear都是front之后，随着入队出队的操作，最终。：栈的插入操作，叫做进栈/压栈/入栈，入数据在栈顶。
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
数据结构栈和队列（参考代码）
06-18
数据结构栈和队列的课程指导上几实验代码 相抵部分
数据结构-栈
2202_75509654的博客
05-19 379
顺序栈：int maxlen;int top;}sqstack;
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
qq_50891451的博客
05-22 407
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
C-数据结构-单向链表（示例）
最新发布
aqiangdeba的博客
05-22 94
【代码】C-数据结构-单向链表（示例）
数据结构（队列）
wan__cheng的博客
05-22 98
概念：队列是一种线性表，它只能从一端插入数据，从另一端删除数据，在插入数据的一端称为队头，在删除数据的一端称为队尾。队列遵循先进先出的原则。队列的实现建议使用链表来实现，因为如果用数组的话出队列要调整数组，比较麻烦，而使用链表实现就可以避免这个问题。生动形象一点就跟我们日常排队一样，先排的人先走，后排的人后走。
P0【知识点】【数据结构】【数组Array】讲解C++版
qq_50891451的博客
05-16 246
大O表示法 O(1) < O(logN) < O(N) < O(NlogN) < O(N^2) < O(2^N)at() 这个方法返回的是一个引用，可以吧一个常量 int 赋值给它。数组索引（Access）：是通过数组的下标去找这个元素。大O表示法 O(1) < O(N) < O(N^2)数组搜索（Search）：是找这个元素的位置（索引）3.插入 Insert O(N)4.删除 Delete O(N)1.访问access O(1)2.搜索search O(N)【485】最大连续1的个数。
数据结构栈和队列思维导图
04-14
我理解你的问题是关于数据结构栈和队列思维导图的。下面是我提供的思维导图： - 栈是一种后进先出（LIFO）的数据结构，它的操作只能在栈顶进行。 - 基本操作：push（入栈）、pop（出栈）、top（访问栈顶元素）、isEmpty（判断栈是否为空）、isFull（判断栈是否已满）。 - 应用场景：函数调用栈、符号匹配、表达式计算等。 - 队列是一种先进先出（FIFO）的数据结构，它的操作包括在队尾插入元素，在队头删除元素。 - 基本操作：enqueue（入队）、dequeue（出队）、front（队头元素）、rear（队尾元素）、isEmpty（判断队列是否为空）、isFull（判断队列是否已满）。 - 应用场景：广度优先搜索、消息队列、进程调度等。 希望这个思维导图能够为你提供一些帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值