【数据结构】栈和队列

最新推荐文章于 2025-06-27 17:12:49 发布
最新推荐文章于 2025-06-27 17:12:49 发布
阅读量106 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/StandDev/article/details/132219419

文章目录

一、栈的概念和结构

栈一种特殊的线性表，它只允许在固定的一端进行插入和删除元素操作；进行数据插入和删除操作的一端称为栈顶，另一端称为栈底；栈中的数据元素遵守后进先出 LIFO（Last In First Out）的原则；

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶；出栈：栈的删除操作叫做出栈，出数据也在栈顶；

在这里插入图片描述

注意：不要把栈区和栈混为一谈：栈区是内存划分的一块区域，属于操作系统学科；而栈是用于管理数据的一种结构，它在堆区上申请空间，属于数据结构学科。

二、顺序栈的实现

1. 结构的定义

栈可以用顺序表实现，也可以用链表实现，这里选用顺序表实现，原因如下：

1、栈的插入和删除操作都在栈顶，即在数据的尾部进行，而顺序表在尾部插入和删除数据的效率为O(1)，完美的避开了顺序表的缺陷；

2、顺序表扩容和链表频繁 malloc 在整体上的效率是差不多的，只是顺序表会存在一定的空间浪费；

3、顺序表支持随机访问，且其缓存利用率更高；

综合考虑以上几种因素，我们采用顺序表实现栈；

typedef int ASDataType;
typedef struct Stack
{
	ASDataType* val;
	int top;
	int capacity;
}Stack;

这里的top指针和顺序表的size是等价的

2. 初始化栈

函数调用者需要在外面先定义一个Stack变量，然后把栈的地址传进来，在Init函数中初始化栈为空

void InitStack(Stack* ps)
{
	assert(ps);
	ps->val = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

3. 入栈

由于栈只能在栈顶插入元素，所以我们只需要在 push 函数中进行检查容量并扩容，而不需要把 CheckCapacity 单独封装成一个函数。

void EnStack(Stack* ps, ASDataType x)
{
	assert(ps);
	if (ps->capacity == ps->top)//扩容
	{
		int NewCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		ASDataType* temp = (ASDataType*)realloc(ps->val, NewCapacity * sizeof(ASDataType));
		if (temp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		ps->val = temp;
		ps->capacity = NewCapacity;
	}
	ps->val[ps->top] = x;
	ps->top++;
}

4. 出栈

出栈之前我们需要检查栈是否为空

void DeStack(Stack* ps)
{
	assert(ps);
	if (ps->top == 0)
	{
		printf("栈为空，删除失败！\n");
		return;
	}
	ps->top--;
}

5. 获取栈顶元素

获取栈顶元素时我们也需要检查栈是否为空，避免造成对空指针的解引用。

ASDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->val[ps->top - 1];
}

6. 获取栈的长度

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

7. 判空

bool IsEmptyStack(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}

8. 销毁栈

void DestroyStack(Stack* ps)
{
	assert(ps);
	free(ps->val);
	ps->val = NULL;
	ps->capacity = ps->top = 0;
}

需要注意的是，我们不需要定义栈的打印函数，因为栈不能遍历，如果我们想得到栈顶的前一个元素，我们就必须先把栈顶的元素给删除掉，让后面一个元素变成栈顶。

三、完整代码

1. Stack.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int ASDataType;
typedef struct Stack
{
	ASDataType* val;
	int top;
	int capacity;
}Stack;

//初始化栈
void InitStack(Stack* ps);

//入栈
void EnStack(Stack* ps, ASDataType x);

//出栈
void DeStack(Stack* ps);

//判空
bool IsEmptyStack(Stack* ps);

//取栈顶元素
ASDataType StackTop(Stack* ps);

//求栈的大小
int StackSize(Stack* ps);

//销毁栈
void DestroyStack(Stack* ps);

2. Stack.c

#include"Stack.h"

void InitStack(Stack* ps)
{
	assert(ps);
	ps->val = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void EnStack(Stack* ps, ASDataType x)
{
	assert(ps);
	if (ps->capacity == ps->top)//扩容
	{
		int NewCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		ASDataType* temp = (ASDataType*)realloc(ps->val, NewCapacity * sizeof(ASDataType));
		if (temp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		ps->val = temp;
		ps->capacity = NewCapacity;
	}
	ps->val[ps->top] = x;
	ps->top++;
}

void DeStack(Stack* ps)
{
	assert(ps);
	if (ps->top == 0)
	{
		printf("栈为空，删除失败！\n");
		return;
	}
	ps->top--;
}


bool IsEmptyStack(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}

ASDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->val[ps->top - 1];
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

void DestroyStack(Stack* ps)
{
	assert(ps);
	free(ps->val);
	ps->val = NULL;
	ps->capacity = ps->top = 0;
}

3. test.c

#include"Stack.h"
int main()
{
	Stack S;
	InitStack(&S);
	EnStack(&S, 1);
	EnStack(&S, 2);
	EnStack(&S, 3);
	EnStack(&S, 4);
	EnStack(&S, 5);
	printf("栈的大小：%d\n", StackSize(&S));
	int n = 5;
	while (n--)
	{
		printf("%d\n", StackTop(&S));
		DeStack(&S);
	}
	printf("%d\n", IsEmptyStack(&S));
	DestroyStack(&S);
	return 0;
}

四、 队列的概念和结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表；队列中的数据元素遵守先进先出 FIFO（First In First Out）的原则；

入队列：进行插入操作的一端称为队尾；出队列：进行删除操作的一端称为队头。

在这里插入图片描述

五、链式队列的实现

1. 队列结构的定义

和栈一样，队列既可以使用顺序表实现，也可以使用链表实现，这里我们使用单链表实现，原因如下：

1、队列需要删除头部的元素，单链表头删的效率为O(1)；

2、使用链表可以按需申请空间，避免了空间的浪费；

但是我们发现使用单链表实现队列存在一个问题，那就是单链表尾插以及计算链表长度的效率都为O(N)，不符合我们的预期，那么我们需要把单链表改造为循环链表吗？可以是可以，但是这样又把队列的结构搞复杂了；所以综合考虑，这里我们增加三个变量，一个用于记录队尾，一个用于记录队头，还有一个用于记录队列的长度。

typedef int LQDataType;

typedef struct QNode //队列结点
{
	LQDataType val;
	struct QNode* next;
}QNode;

typedef struct Queue //队列
{
	QNode* head; //队头指针
	QNode* tail; //队尾指针
	int size; //记录队列长度
}Queue;

2. 初始化队列

void InitQueue(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

3. 入队

由于我们使用了一个结构体来记录队列的头指针和尾尾指针，那么这里我们改变队列的头指针和尾指针时只需要改变结构体即可，所以只需要传递一级指针；

另外，队列也只能从队尾入数据，所以我们也没有必要单独封装一个 BuyNode 函数。

void EnQueue(Queue* pq, LQDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("EnQueue");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->val = x;
	if (pq->head == NULL)
	{
		pq->head = newnode;
		pq->tail = newnode;
	}
	else
	{
		newnode->next = pq->tail->next;
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}

4. 出队

这里除了正常地对队列进行判空之外，还有一个需要特别注意的地方：当队列只有一个元素时，我们再次头删虽然会让head指向NULL，但是tail仍然指向头删之前的那个节点，没有置空，会形成野指针，所以我们这里需要单独处理这种情况

void DeQueue(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
	else
	{
		QNode* temp = pq->head->next;
		free(pq->head);
		pq->head = temp;
	}
	pq->size--;
}

5. 获取队头元素

LQDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->head->val;
}

6. 获取队尾元素

LQDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->tail);
	return pq->tail->val;
}

7. 获取队列长度

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

8. 判空

bool IsEmptyQueue(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

9. 销毁队列

void DestroyQueue(Queue* pq)
{
	assert(pq);
	while (pq->head)
	{
		DeQueue(pq);
	}
}

注意：和栈一样，队列也不需要定义 print 函数，因为队列也不能遍历，要想取出队头后面的元素，我们必须先 pop 掉队头的元素，让该元素成为队头。

六、完整代码

1. Queue.h

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int LQDataType;

typedef struct QNode //队列结点
{
	LQDataType val;
	struct QNode* next;
}QNode;

typedef struct Queue //队列
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

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

//入队
void EnQueue(Queue* pq, LQDataType x);

//出队
void DeQueue(Queue* pq);

//判空
bool IsEmptyQueue(Queue* pq);

//队列大小
int QueueSize(Queue* pq);

//返回队头元素
LQDataType QueueFront(Queue* pq);

//返回队尾元素
LQDataType QueueBack(Queue* pq);

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

2. Queue.c

#include"Queue.h"

void InitQueue(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

void EnQueue(Queue* pq, LQDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("EnQueue");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->val = x;
	if (pq->head == NULL)
	{
		pq->head = newnode;
		pq->tail = newnode;
	}
	else
	{
		newnode->next = pq->tail->next;
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}

void DeQueue(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
	else
	{
		QNode* temp = pq->head->next;
		free(pq->head);
		pq->head = temp;
	}
	pq->size--;
}

bool IsEmptyQueue(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

LQDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->head->val;
}

LQDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->tail);
	return pq->tail->val;
}

void DestroyQueue(Queue* pq)
{
	assert(pq);
	while (pq->head)
	{
		DeQueue(pq);
	}
}

3. test.c

#include"Queue.h"
int main()
{
	Queue Q;
	InitQueue(&Q);
	EnQueue(&Q, 1);
	printf("%d\n", QueueBack(&Q));
	EnQueue(&Q, 2);
	printf("%d\n", QueueBack(&Q));
	EnQueue(&Q, 3);
	printf("%d\n", QueueBack(&Q));
	EnQueue(&Q, 4);
	printf("%d\n", QueueBack(&Q));
	EnQueue(&Q, 5);
	printf("%d\n", QueueBack(&Q));
	printf("队列大小为：%d\n", QueueSize(&Q));
	int n = 5;
	while (n--)
	{
		printf("%d\n", QueueFront(&Q));
		DeQueue(&Q);
	}
	printf("%d\n", IsEmptyQueue(&Q));
	DestroyQueue(&Q);
	return 0;
}
数据结构 栈和队列
qq_52847866的博客
06-15 4702
5. 访问效率：顺序存储结构的元素在内存中是连续存储的，对于 CPU 缓存等硬件有较好的利用效率，因此在访问速度上可能更快。特殊矩阵的压缩存储可以大幅减少存储空间的占用，提高存储效率，并在某些情况下加速矩阵的运算和操作。需要注意的是，多维数组的存储方式可能会影响程序的性能，特别是对于大型多维数组和对数组访问频繁的场景。总之，栈和队列都是重要的数据结构，在不同的应用场景中发挥着关键的作用。栈和队列都是常见的数据结构，可以使用不同的存储结构进行实现，包括顺序存储结构和链式存储结构。函数判断栈是否为空。
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 29万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构栈和队列
m0_65185254的博客
10-28 5555
数据结构作业
[C/C++]数据结构 栈和队列
m0_74910646的博客
11-18 1459
是一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作,进行数据插入和删除操作的一端称为,另一端称为,栈中的数据元素遵守的原则.
数据结构——栈和队列
m0_65121602的博客
02-15 955
栈和队列是两种常见的数据结构，它们在计算机科学中有着广泛的应用。栈和队列作为基础数据结构，在很多计算机算法和实际应用中都扮演着重要角色。它们的基本操作简单，适用于多种场景。理解这两者的区别和应用，有助于更好地解决实际问题。
数据结构栈和队列的基本操作
lizhi20210729的博客
11-21 1709
前言 这一篇我就不附书上代码了，太慢。 线性表的应用 线性表的合并 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(
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 2765
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
数据结构之栈和队列(超详解)
egoist2023的博客
02-03 2229
详解栈和队列的底层和使用及涉及的相关题型
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构栈和队列（参考代码）
06-18
### 数据结构栈和队列知识点解析 #### 一、栈的基本概念与操作 **栈**是一种特殊的线性表，只允许在一端进行插入和删除操作，这一端被称为栈顶，另一端被称为栈底。栈遵循先进后出（First In Last Out, FILO）的...
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
数据结构栈和队列练习题答案.doc
04-02
数据结构
数据结构栈和队列解决迷宫问题
06-07
数据结构栈和队列解决迷宫问题 本文档详细介绍了利用栈和队列解决迷宫问题的步骤，对于初学者学习数据结构能很好的进行辅导。本文档主要涉及到数据结构的两个重要概念：栈和队列，并介绍了如何使用这两个数据结构来...
数据结构day1
weixin_72086349的博客
06-23 476
本文摘要：数据结构是相互关联的数据元素集合，包括逻辑结构（集合、线性、树、图）和物理结构（顺序、链式存储）。数据元素由数据项组成，抽象数据类型(ADT)定义数据集合及其操作。算法需具备输入输出、有穷性、确定性等特征，设计时应考虑正确性、可读性、高效性。时间复杂度分析遵循特定规则，常见复杂度排序为O(1) < O(logn) < O(n) < O(nlogn) < O(n²)等。线性表是有限元素序列，包含创建、销毁、遍历和插入等基本操作，通过结构体和指针实现顺序存储管理。
AcWing--数据结构（二）
最新发布
a3040218的博客
06-27 607
用来高效的快速存储和查找字符串集合的数据结构如存储：abcdef,abdef,aced,...从根节点开始存储，从前往后存储，看是否有a，没有就创建，依次存储。一般在最后一个字符打个标记，意思就是当前字符结尾有个单词。对于查找，要找aced就从根节点看，如果走到结尾且有标记，就是存在，没有就不存在。// 0号点既是根节点，又是空节点// son[][]存储树中每个节点的子节点// cnt[]存储以每个节点结尾的字符串数量// 插入一个字符串int p = 0;
Python-3-数据结构（列表）
M7777777777777的博客
06-24 257
根据某种方式，将数据元素组合起来形成一个数据元素的集合Python数据结构主要有序列（如列表、元组）、映射（字典）、集合3种基本的数据结构类型。
数据结构——队列
2401_88326089的博客
06-24 1050
本文介绍了队列(Queue)这一先进先出(FIFO)的线性数据结构，重点讲解了两种实现方式：链表队列和循环队列。文章还比较了栈与队列的异同，包括逻辑结构、存储方式和运算规则。通过具体代码示例展示了两种队列的实现方法，为理解队列这一基础数据结构提供了实用参考。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值