数据结构——栈和队列

已于 2024-10-05 23:53:32 修改
阅读量503 收藏 18
点赞数 15
分类专栏： 数据结构 文章标签： 数据结构
于 2024-10-05 23:52:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zoelinkailuo/article/details/142720785
版权

数据结构——栈和队列

文章目录

一、栈

1.概念

  • 栈：⼀种特殊的线性表，其只允许在固定的⼀端进⾏插⼊和删除元素操作。
  • 栈顶和栈底：进⾏数据插⼊和删除操作的⼀端称为栈顶，另⼀端称为栈底。
  • 压栈：栈的插⼊操作叫做进栈/压栈/⼊栈，⼊数据在栈顶。
  • 出栈：栈的删除操作叫做出栈，出数据也在栈顶。
  • 栈的特点： 栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

2.结构

栈底层结构选型

栈的实现⼀般可以使⽤数组或者链表实现，相对⽽⾔数组的结构实现更优⼀些。分析如下：

1.数组：

时间复杂度为O(1)，但需要增容：realloc；

操作系统后面的空间足够时是原地增容，不够时需要进行异地增容，需要额外开辟大的存储空间，拷贝旧数据，释放旧空间，这里虽然会存在一定的性能消耗，但是因为我们的增容都是乘2倍的进行，所以哪怕是异地增容，它增容的次数都很少，效率消耗可以不计，不需要频繁的向操作系统申请空间。

2.单链表：

（1）.栈顶在尾部：压栈相当于链表的尾插，出栈相当于尾删，都需要根据头结点phead进行遍历找到尾结点，时间复杂度均为O(N);

（2）.栈顶在头部：压栈相当于链表的头插，时间复杂度为O(1)。出栈：就是让下一个结点作为新的头结点，然后把头结点释放掉，栈顶在头结点的位置，时间复杂度为O(1)；

3.双向链表：

时间复杂度都是一样的，均为O(1)。因为双链表中有2个指针，单链表中只有一个，所有双链表比单链表更占内存，首先排除。

更推荐数组的原因：缓存的问题。

数组申请的空间是一块连续的空间，链表每个节点的地址空间不一定是连续的。

比如我们现在要向数组或者是顺序表里面去存储数据，那么CPU会去执行指令，先去访问内存，内存会去读取一片连续的数据进行缓存，防止之后再用，避免频繁地去访问。在这方面数组比链表更优。

这里我们选择数组作为栈的底层结构。
  • 逻辑结构：线性的
  • 物理结构：线性的

3.栈的实现

在这里插入图片描述

定义栈的结构：

typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;
	int capacity;//栈的空间大写
	int top;//栈顶
}ST;
3.1初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}
3.2销毁
void STDestroy(ST* ps)
{
	assert(ps);
	if (ps->arr)
		free(ps->arr);
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}
3.3入数据
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//1.判断空间是否足够
	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
	//空间一定够
	ps->arr[ps->top++] = x;
}
3.4出数据
void StackPop(ST* ps)
{
	assert(ps&&ps->top!=0);
	--ps->top;
}
3.5取栈顶元素
STDataType StackTop(ST* ps)
{
	assert(ps&&ps->top!=0);
	return ps->arr[ps->top - 1];
}
3.6获取栈中有效元素个数
int STSize(ST* ps)
{
	assert((ps));
	return ps->top;
}

4.完整代码

4.1.Stack.h

该部分是栈结构的定义、函数的声明.

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
//定义栈的结构
typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;
	int capacity;//栈的空间大写
	int top;//栈顶
}ST;

void STInit(ST* ps);
void STDestroy(ST* ps);

//栈顶---入数据，出数据
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);

//取栈顶元素
STDataType StackTop(ST* ps);

bool StackEmpty(ST* ps);

//获取栈中有效元素个数
int STSize(ST* ps);
4.2.Stack.c

该部分是函数功能的实现.

#include"Stack.h"

void STInit(ST* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}
void STDestroy(ST* ps)
{
	assert(ps);
	if (ps->arr)
		free(ps->arr);
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//1.判断空间是否足够
	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
	//空间一定够
	ps->arr[ps->top++] = x;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	--ps->top;
}
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->arr[ps->top - 1];
}

int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
4.3.test.c

该部分用于测试，函数的调用.

#include"Stack.h"

void STTest()
{
	ST st;
	STInit(&st);
	/
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	printf("size:%d\n", STSize(&st));
	//StackPop(&st);
	//循环出栈，直到栈为空
	while (!StackEmpty(&st))
	{
		STDataType data = StackTop(&st);
		printf("%d ", data);
		//出栈
		StackPop(&st);
	}
	printf("size:%d\n", STSize(&st));

	
	//STDestroy(&st);
}
int main()
{
	STTest();
	return 0;
}

二、队列

1.概念

  • 队列：只允许在⼀端进⾏插⼊数据操作，在另⼀端进⾏删除数据操作的特殊线性表。

  • ⼊队列：进⾏插⼊操作的⼀端称为队尾。

  • 出队列：进⾏删除操作的⼀端称为队头。

  • 队列的特点：队列中的数据元素遵守先进先出FIFO(First In First Out)的原则。

2.结构

队列底层结构选型

队列也可以数组和链表的结构实现，使⽤链表的结构实现更优⼀些。分析如下：

1.数组:

前队头后队尾；入队的时间复杂度为O(1),但出队的时间复杂度O(N)。

2单链表:

头结点定为队头，最后一个结点定为队尾；

出队相当于头删，时间复杂度为O(1)，入队相当于尾插，时间复杂度为O(N）(因为需要遍历ptail)，如果定义一个尾结点ptail(额外增加一个指针），那么时间复杂度可以从O(N)降到O(1)，由此，我们选择链表。

要是反过来，队头定义成最后一个节点的话，删除最后一个节点，我们不能找到最后一个节点的前一个节点。所以不行！！

更推荐链表的原因：因为如果使⽤数组的结构，出队在数组头上出数据，效率会⽐较低。

底层结构是链表

这里我们选择单链表作为队列的底层结构。
  • 逻辑结构：线性的
  • 物理结构：不一定是线性的

3.队列的实现

在这里插入图片描述

定义队列的结构：

//定义队列结点的结构
typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QueueNode;

typedef struct Queue
{
	QueueNode* phead;//队头
	QueueNode* ptail;//队尾
	int size;//保存队列有效数据个数
}Queue;
3.1初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
3.2入队列（队尾）
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//申请新的结点
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->phead == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		//队列不为空
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}
3.3出队列（队头）
void QueuePop(Queue* pq)
{
	assert(pq&&pq->phead!=NULL&&pq->ptail!=NULL);

	//只有一个结点的情况，避免ptail变成野指针
	if (pq->ptail == pq->phead)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		//删除对头结点
		QueueNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	--pq->size;
}
3.4取队头数据
QDataType QueueFront(Queue* pq)
{
	assert(pq&&pq->phead!=NULL&&pq->ptail!=NULL);
	return pq->phead->data;
}
3.5取队尾数据
QDataType QueueBack(Queue* pq)
{
	assert(pq&&pq->phead!=NULL&&pq->ptail!=NULL);
	return pq->ptail->data;
}
3.6队列有效元素个数

在这里，大家可以思考一下下面代码有什么问题？

//队列有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QueueNode* pcur = pq->phead;
	while (pcur)
	{
		size++;
		pcur = pcur->next;
	}
	return size;
}

想到了吗？

答案是：队列不可以遍历，队列只能一端进一端出，要不然岂不是每个结点都能取到了？而且它的时间复杂度是O(N),要是进行频繁的遍历的话，程序效率会比较低。

我们可以在定义队列结构时，就多定义一个size(用于保存队列有效数据个数)，这里在上面我已经定义好了，可以直接使用，如下：

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
3.7销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq&&pq->phead!=NULL&&pq->ptail!=NULL);

	QueueNode* pcur = pq->phead;
	while (pcur)
	{
		Queue* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

4.完整代码

4.1.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* phead;
	QueueNode* ptail;
	int size;//保存队列有效数据个数
}Queue;

void QueueInit(Queue* pq);

// ⼊队列，队尾
void QueuePush(Queue* pq, QDataType x);
// 出队列，队头
void QueuePop(Queue* pq);
//队列判空
bool QueueEmpty(Queue* pq);

//取队头数据
QDataType QueueFront(Queue* pq);
//取队尾数据
QDataType QueueBack(Queue* pq);
//队列有效元素个数
int QueueSize(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);
4.2.Queue.c

该部分是函数功能的实现.

#include"Queue.h"
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//申请新的结点
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->phead == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		//队列不为空
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL && pq->ptail == NULL;
}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	//只有一个结点的情况，避免ptail变成野指针
	if (pq->ptail == pq->phead)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		//删除对头结点
		QueueNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	--pq->size;
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->phead->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->ptail->data;
}
//队列有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);
	/*int size = 0;
	QueueNode* pcur = pq->phead;
	while (pcur)
	{
		size++;
		pcur = pcur->next;
	}
	return size;
	*/
	return pq->size;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	QueueNode* pcur = pq->phead;
	while (pcur)
	{
		Queue* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
4.3.test.c

该部分用于测试，函数的调用.

#include"Queue.h"

void QueueTest01()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

	//QueuePop(&q);
	printf("head:%d\n", QueueFront(&q));
	printf("tail:%d\n", QueueBack(&q));
	printf("size:%d\n", QueueSize(&q));
	QueueDestroy(&q);
}

int main()
{
	QueueTest01();
	return 0;
}

三、总结

在数据结构的丰富多样的领域中，栈和队列作为两种基本的线性数据结构，各自以其独特的特点和应用场景，展现了它们在数据处理中的不可或缺性。
希望本篇博客对你的学习有所帮助，有任何问题，欢迎在评论区留言哦~
林开落L
关注
专栏目录
C++实现的任意进制转换（数据结构——栈和队列）
08-10
本文将深入探讨如何使用C++语言实现任意进制转换，特别是涉及到小数部分的处理，并结合数据结构中的栈和队列进行阐述。C++作为一门强大的静态类型语言，其丰富的库支持和高效性能使得它成为实现这种算法的理想选择。...
数据结构——栈和队列（详解）
2302_80023639的博客
03-09 891
栈，一种仅允许在一端进，一端出的结构如上图所示，进数据和出数据的一端叫做栈顶，而相反的一段则叫做栈底数据从栈顶入，从栈顶出我们可以以吃货的视角打开栈：栈就像一个肉串，串肉要从尖的一段串进去，同时也是从尖的一端被吃掉我们还能发现，先被串进去的肉，会最后被吃掉栈也是如此，符合FILO原则，FILO就是 first in last out，翻译过来就是先进后出就像我们日常生活中的排队一样，队列就是从一端进，从另一端出。
数据结构——栈和队列详细解释
m0_61886762的博客
09-24 2554
你们在使用电脑中也会经历过机器有时会处于疑似死机的状态，鼠标点什么地方都没有任何反应，双击任何快捷键都不动弹。就当你失去内心时，机器突然对你刚的所有操作都执行了一遍。这是因为操作系统在当时可能CPU没有忙过来。操作系统中应用了一种数据结构来实现上述所说的问题也就是先进先出的功能，这就是队列。队列是一种先进先出的线性表简称FIFO。允许插入的操作为队尾，允许删除的操作为队头。就类似于最近几年的做核酸排队的操作，你在入队时是从队尾排队做核酸，做完之后是从队伍的头部做完后退出队伍。
【算法竞赛】堆
Sakura_ding的博客
10-01 995
堆是一种树形结构,树的根是堆顶,堆顶始终保持为所有元素的最优值。有最大堆和最小堆,最大堆的根节点是最大值,最小堆的根节点是最小值。本节都以最小堆为例进行讲解。堆一般用二叉树实现,称为二叉堆。二叉堆的典型应用有堆排序和优先队列。
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 355
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】【顺序表算法】 删除特定范围内的元素
最新发布
Indigo____的博客
10-04 260
题目：从顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。
（JAVA）队列 和 符号表 两种数据结构的实现
ZunXin_2580的博客
09-27 681
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1089
本文介绍了数据结构中的AVL树，给出了C++的代码实现
数据结构-3.8.栈在括号匹配中的应用
ADCvbV的博客
10-01 530
把左括号依次压入栈中，越往后压入栈的左括号越先被匹配即被弹出栈->先进后出，后进先出当遇到左括号就压入栈中，当遇到右括号就把栈顶的左括号弹出，检查该右括号和左括号是否匹配当遇到一个不匹配的就停止压入栈，因为之后的括号必定都不匹配。其中Y代表Yes，N代表No1.对于bracketCheck函数，形参str[]是传入的一个字符串，length是该字符串的长度；字符topElem代表栈顶元素；return StackEmpty(S)如果是return false说明栈不为空，则左括号单身；创建栈顶元素topEl
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 332
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
数据结构-4.2.串的定义和基本操作
ADCvbV的博客
10-01 332
1.单/双引号不是字符串里的内容，他只是一个边界符，用来表示字符串的头和尾；2.空串也是字符串的子串，空串长度为0；3.字符的编号是从1开始，不是0；4.空格也是字符；
哈希表(HashMap、HashSet)
wuweixiaoyue的博客
09-28 1080
是个存储结构：可以让我们一次从表中直接拿到想要的元素，时间复杂度为O(1)为什么能实现O(1)：通过哈希(散列)方法，使元素的存储位置和它的关键码之间建立一一映射的关系如果想要存取元素，都是利用哈希(散列)方法 + 关键码，从而计算出index位置，然后进行操作（怎么放的就怎么给它取出来哈希函数示例：此时写着容量是1000，但实际上是2次幂数，容量为1024。
【堆排】为何使用向下调整法建堆比向上调整法建堆更好呢？
2301_80085602的博客
10-01 1436
在博主的上一篇博客堆排(链接在这里点击即可)的总结中提出啦使用向上调整法建堆比使用向下调整法建堆更好，是因为使用向上调整法建堆的时间复杂度为O(n)，使用向下调整法建堆的时间复杂度为O(n*logn)。接下来博主就教大家如何计算它们的时间复杂度。通过这篇博客相信柚柚们已经清楚向下调整法建堆和向上调整法建堆的时间复杂度怎么计算啦，后期博主还会更新有关数据结构的博客，感兴趣的柚柚们可以关注博主喔~
排序算法之归并排序
qq_64039411的博客
10-01 511
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
机器人的运动范围
weixin_72952570的博客
09-29 486
剑指offer的一道经典题目。
数据结构-队列
2401_83575662的博客
10-01 352
队列：是一种特殊的线性表，只允许在一端进行数据的插入操作，在另一端进行数据的删除操作。队列的特性是队里的元素都遵循先进先出FIFO(First In First Out)的原则。入队列：进行数据插入的一端被称为队尾。出队列：进行数据删除的一端被称为队头。
数据结构-3.5.队列的顺序实现
ADCvbV的博客
09-28 1026
可能会问，此时不是还剩一个存储空间吗，为什么认为满了呢，但需要注意的是，初始化队列时，队头指针和队尾指针是指向了同一个位置，因此判断是否队列已经满了，也需要看队头指针和队尾指针是否指向了同一个位置(注：队尾指针指向下一个插入元素的位置)#define MaxSize 10 //定义一个队列最多存储的元素个数​//用静态数组存放队列元素int front;//队头指针,队头删除元素int rear;//队尾指针,队尾插入元素}SqQueue;​//初始化队列//初始时，队头和队尾指针都指向0。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值