栈与队列的故事

最新推荐文章于 2024-09-12 17:17:36 发布
最新推荐文章于 2024-09-12 17:17:36 发布
阅读量1.3k 收藏 84
点赞数 101
分类专栏： 数据结构 文章标签： 数据结构 算法 栈与队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65931202/article/details/136596503
版权

​​​​​​​

目录

​编辑​​​​​​​

一、栈

1.1栈的概念及结构

1.2栈的实现

1、实现支持动态增长的栈

2、初始化栈

3、入栈

4、出栈

5、获取栈顶元素

6、检测栈是否为空

7、获取栈中有效元素个数

8、销毁栈

9、测试

1.3源码

二、队列

2.1队列的概念及结构

2.2队列的实现

1、链式结构：表示队列

2、队列的结构

3、初始化队列

4、队尾入队列

5、队头出队列

6、获取队列队头元素

7、获取队列队尾元素

8、获取队列中有效元素个数

9、检测队列是否为空

10、销毁队列

11、测试

2.3源码

一、栈

1.1栈的概念及结构

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

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

1.2栈的实现

栈的实现一般可以使用数组或者链表实现：

  • 对于链表而言又有双向链表和单链表，如果用双向链表实现，栈顶既可以是尾，也可以是头。如果用单链表实现，栈顶只能是头，因为单链表尾插容易，尾删却比较麻烦；而头插头删都很容易。
  • 相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

1、实现支持动态增长的栈

typedef int STDataType;

typedef struct stack
{
	STDataType* arr;
	int top;      //栈顶
	int capacity; //容量
}ST;

2、初始化栈

因为这个结构体肯定不可能为空，所以我们直接先断言它。然后，这里还有一个要特别注意的点，如果我们初始化时top给0，那top指向的就是栈顶元素的下一个位置；如果top给-1，那top就指向栈顶元素。

void STInit(ST* pst)
{
	assert(pst);

	pst->arr = NULL;
	pst->capacity = 0;

	//表示top指向栈顶元素的下一个位置
	pst->top = 0;
	表示top指向栈顶元素
	//pst->top = -1;
}

3、入栈

入栈时如果空间不够，先扩容；因为top此时是指向栈顶元素的下一个位置，所以我们直接将要入栈的元素x放在top位置，然后让top指向下一个位置就行。

void STPush(ST* pst, STDataType x)
{
	assert(pst);

	//扩容
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->arr, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->arr = tmp;
		pst->capacity = newcapacity;
	}

	pst->arr[pst->top] = x;
	pst->top++;

    //如果top初始化时为-1，入栈时就要top先++，再将元素放进去
	//pst->top++;
	//pst->arr[pst->top] = x;
}

4、出栈

在出栈时要注意如果top为0就不能在删除了，所以要断言一下。

void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);

	pst->top--;
}

5、获取栈顶元素

因为top是指向栈顶元素的下一个位置，所以要获取栈顶元素只需要top-1就行。

STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);

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

6、检测栈是否为空

如果栈为空，那top就等于0，表达式的结果就为真；如果表达式的结果为假，就代表栈不为空。

bool STEmpty(ST* pst)
{
	assert(pst);

	return pst->top == 0;
}

7、获取栈中有效元素个数

int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}

8、销毁栈

void STDestroy(ST* pst)
{
	assert(pst);

	free(pst->arr);
	pst->arr = NULL;

	pst->top = pst->capacity = 0;
}

9、测试

int main()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	STPush(&s, 4);
	STPush(&s, 5);
	while (!STEmpty(&s))
	{
		printf("%d ", STTop(&s));
		STPop(&s);
	}
	printf("\n");
	STDestroy(&s);

	return 0;
}

1.3源码

🌻Stack.h

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


typedef int STDataType;

typedef struct stack
{
	STDataType* arr;
	int top;      //栈顶
	int capacity; //容量
}ST;

//初始化
void STInit(ST* pst);
//销毁栈
void STDestroy(ST* pst);
//入栈
void STPush(ST* pst, STDataType x);
//出栈
void STPop(ST* pst);
//获取栈顶元素
STDataType STTop(ST* pst);
//检测栈是否为空，如果为空，返回真；如果不为空，返回假
bool STEmpty(ST* pst);
//获取栈中有效元素个数
int STSize(ST* pst);

🌻Stack.c

#include "stack.h"

//初始化
void STInit(ST* pst)
{
	assert(pst);

	pst->arr = NULL;
	pst->capacity = 0;

	//表示top指向栈顶元素的下一个位置
	pst->top = 0;

    //表示top指向栈顶元素
	//pst->top = -1;
}

//销毁栈
void STDestroy(ST* pst)
{
	assert(pst);

	free(pst->arr);
	pst->arr = NULL;

	pst->top = pst->capacity = 0;
}

//入栈
void STPush(ST* pst, STDataType x)
{
	assert(pst);

	//扩容
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->arr, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->arr = tmp;
		pst->capacity = newcapacity;
	}
    
    //如果top初始化时为0，入栈时就要先将元素放进去，再将top++
	pst->arr[pst->top] = x;
	pst->top++;

	//如果top初始化时为-1，入栈时就要top先++，再将元素放进去
	//pst->top++;
	//pst->arr[pst->top] = x;
}

//出栈
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);

	pst->top--;
}

//获取栈顶元素
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);

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

//检测栈是否为空，如果为空，返回真；如果不为空，返回假
bool STEmpty(ST* pst)
{
	assert(pst);

	return pst->top == 0;
}

//获取栈中有效元素个数
int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}

二、队列

2.1队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)的特点。

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

2.2队列的实现

队列也可以数组和链表的结构实现，但使用链表的结构实现会更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

1、链式结构：表示队列

typedef int QDataType;

//链式结构：表示队列
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QNode;

2、队列的结构

因为队列需要队头和队尾两个指针，所以为了方便管理，我们可以把它俩放在一个结构体里边。

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
    int size;
}Queue;

3、初始化队列

void QueueInit(Queue* pq)
{
	assert(pq);

	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

4、队尾入队列

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->val = x;
	newnode->next = NULL;

	if (pq->ptail == NULL)
	{
		pq->ptail = pq->phead = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

5、队头出队列

出队时得考虑两种情况，一种是队列为空，另一种是队列中只有一个节点；如果队列为空，我们只需断言一下就行。如果队列中只有一个节点，我们先保存当前节点，然后让头指针指向下一个节点，接着free掉保存的节点，这时如果头指针是指向空的，我们就把尾指针也置空。

void QueuePop(Queue* pq)
{
	assert(pq);
	//空
	assert(pq->phead);

	QNode* del = pq->phead;
	pq->phead = pq->phead->next;
	free(del);
	del = NULL;

	if (pq->phead == NULL)
	{
		pq->ptail = NULL;
	}

    pq->size--;
}

6、获取队列队头元素

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	//空
	assert(pq->phead);

	return pq->phead->val;
}

7、获取队列队尾元素

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	//空
	assert(pq->ptail);

	return pq->ptail->val;
}

8、获取队列中有效元素个数

int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

9、检测队列是否为空

bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->phead == NULL;
}

10、销毁队列

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

	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

11、测试

int main()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");
	QueueDestroy(&q);
	return 0;
}

2.3源码

🌻Queue.h

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

typedef int QDataType;

//链式结构：表示队列
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QNode;

//队列的结构
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	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);
//检测队列是否为空
bool QueueEmpty(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);

🌻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);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->val = x;
	newnode->next = NULL;

	if (pq->ptail == NULL)
	{
		pq->ptail = pq->phead = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

//队头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	//空
	assert(pq->phead);

	QNode* del = pq->phead;
	pq->phead = pq->phead->next;
	free(del);
	del = NULL;

	if (pq->phead == NULL)
	{
		pq->ptail = NULL;
	}

	pq->size--;
}

//获取队列队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	//空
	assert(pq->phead);

	return pq->phead->val;
}

//获取队列队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	//空
	assert(pq->ptail);

	return pq->ptail->val;
}

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

	return pq->size;
}

//检测队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->phead == NULL;
}

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

	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
南风与鱼
关注
  • 101
    点赞
  • 踩
  • 84
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 78
    评论
专栏目录
栈和队列》《
legendarykk的博客
07-10 231
栈和队列
栈与队列
Programmer's Way
02-12 186
栈 栈是限定仅在表尾进行插入和操作的线性表；允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈，栈又称后进先出的线性表(即LIFO结构) 栈是特殊的线性表(限制了这个线性表的插入和删除位置)，有前驱和后继关系，线性表的表尾是指栈顶，栈顶是固定的 栈的插入(push)操作叫进栈(压栈、入栈)，删除(pop)操作叫出栈(弹栈) 顺序栈(栈的顺序存储结构) 当栈...
栈与队列学习总结
guoquanqin的博客
03-20 6121
栈与队列学习总结 栈 结构特点：后进者先出，先进者后出，同时栈是一种“操作受限”的线性表，只允许在一端插入和删除数据 栈既可以用数组来实现，也可以用链表来实现。用数组实现的栈，我们叫作顺序栈，用链表实现的栈，我们叫作链式栈。 时间空间复杂度分析 在入栈和出栈过程中，只需要一两个临时变量存储空间，所以空间复杂度是 O(1)。 不管是顺序栈还是链式栈，入栈、出栈只涉及栈顶个别数据的操作，所以时间复杂度都是 O(1)。 特殊情况： 对于出栈操作来说，不会涉及内存的重新申请和数据的搬移，所以出.
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 24万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
栈与队列详解
雅俗共赏
05-22 7802
目录申明1. 栈的定义1.1 栈的定义1.2 进栈出栈变化形式2. 线性表的抽象数据类型3. 线性表的顺序存储结构3. 1 顺序存储定义3. 2 顺序存储方式3. 3 数据长度与线性表长度区别3. 4 地址计算方法4. 顺序存储结构的插入与删除4.1 获得元素操作4.2 插入操作4.3 删除操作4.4 线性表顺序存储结构的优缺点5. 线性表的链式存储结构5.1 顺序存储结构不足的解决方法5.2 线性表链式存储结构定义5.3 头指针与头节点的异同5.4 线性表链式存储结构代码描述6. 单链表的读取7. 单链表
如何使用JavaScript实现栈与队列
12-11
栈和队列是web开发中最常用的两种数据结构。绝大多数用户，甚至包括web开发人员，都不知道这个惊人的事实。如果你是一个程序员，那么请听我讲两个启发性的例子:使用堆栈来组织数据，来实现文本编辑器的“撤消”操作;...
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
数据结构栈和队列试题及答案
11-26
栈与队列均属于线性表的一种特殊形式，该说法正确。 7. **特定输出序列的可行性** 通过一个栈可以输出序列3, 2, 5, 6, 4, 1，这种序列是可行的，因此该说法正确。 8. **栈和队列的定义** 栈和队列都是线性...
数据结构实验报告2-栈与队列-队列基本操作算法-实验内容及要求.docx
07-06
- 采用队头/队尾间隔至少一个空闲元素的方法实现循环队列，这样可以避免队列的物理连续性与逻辑连续性的混淆，同时便于检测队列是否为空或满。 - 当队列为满时尝试执行入队操作，或者队列为时空执行出队操作时，...
栈与队列。
10-11
栈和队列是两种重要的线性结构，定义，表示方法，代码实现
数据结构算法——排序算法
qq_73643693的博客
09-07 857
数据结构中的常见算法——排序算法
栈的内容..
2301_79724394的博客
09-09 203
持续更新，小手动一动，点个关注，谢谢！
【华为OD】2024D卷——生成哈夫曼树
最新发布
weixin_45653183的博客
09-12 905
这是通过构建一种特殊的二叉树来实现的，其中每个字符都位于树的一个叶节点上，且该叶节点到根节点的路径上的边所代表的字符（在哈夫曼编码中通常使用0和1表示）共同构成了该字符的编码。·新节点作为这两个子节点的父节点，而原来的两个节点则成为新节点的左右子节点（通常约定左子节点频率小于等于右子节点）。2、不断从堆中取出两个最小的节点作为左右子树，构造一个新的父节点，其权值为两个节点权值之和，并将新节点插入堆中。·然后，算法反复地选择两个频率最小的节点，将它们合并为一个新的节点，新节点的频率是两个子节点频率之和。
【数据结构】基本概念和术语
Sakura_ding的博客
09-09 910
是指一个数学模型以及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关，即不论其内部结构如何变化，只要它的数学特性不变，都不影响其外部的使用。抽象数据类型和数据类型实质上是一个概念。“抽象”的意义在于数据类型的数学抽象特性。抽象数据类型的定义由一个值域和定义在该值域上的一组操作组成。若按其值的不同特性，可细分为下列三种类型：原子类型 (atomic data type)属原子类型的变量的值是不可分解的。
C语言代码练习(第十八天)
2201_75306399的博客
09-09 1260
C语言代码练习
数据结构 栈 队列
qq_69971969的博客
09-06 620
数据的插入--->入栈 数据的删除----->出栈。函数的调用关系（保护现场，恢复现场操作，遵循先进后出，后进先出）缓存数据：主要使用队列，类似于缓冲区，防止数据丢失。允许从一端插入数据，另一端删除数据的线性存储结构。只允许从一端进行数据的插入和删除的线性存储结构。增栈 减栈：用栈顶的增长方向区分（移动方向）顺序队列：假溢出------>循环队列。满栈 空栈：栈顶所在位置是否存有元素。增栈：从内存低地址向高地址移动。减栈：从内存高地址向低地址移动。链式队列：用链表方式构造队列。
Redis常见的数据结构
weixin_61669379的博客
09-09 1009
Redis底层的数据结构是Redis高效存储和操作数据的基础,Redis提供了五种基本的数据类型，每种类型在底层都有对应的数据结构来实现。这五种数据类型分别是：字符串（String）、哈希（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）。
数据结构——初识数据结构
attitude_lu的博客
09-09 775
简单来说，算法时间复杂度也就是执行这个算法所花时间的度量，算法的时间复杂度是衡量算法执行时间与输入数据量之间的关系的一个指标。比如说算法的实际时间复杂度为2n^2+3n+1但是在进行具体的表示时只保留最高阶项也就是2n^2，根据第三条规则最高阶项的系数不是1时直接看成1只保留n^2项最后算出的时间复杂度就是n^2。树，在数据结构中，树是一种非常重要的非线性结构，它由节点组成，每个节点可以有零个或多个子节点，但只能有一个父节点。大O表示法描述了算法性能的上界，即随着输入规模的增长，算法执行时间的增长率。
从零开始学数据结构系列之第六章《排序简介》
铁匠匠匠的博客
09-12 689
​所谓排序，就是使一串数据，按照其中的某个或某些关键字的大小，递增或递减排列起来的操作。
栈与队列解决小型迷宫问题
"小型迷宫数据结构问题，涉及栈与队列的概念及应用，迷宫解题策略通过栈实现回溯。" 在计算机科学中，数据结构是组织、管理和存储数据的方式，它对于高效地执行算法至关重要。在这个问题中，我们关注的是两种基本的...
评论 78
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

南风与鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值