栈和队列（详解）
博客主页：️自信不孤单
文章专栏：数据结构与算法
代码仓库：破浪晓梦
欢迎关注：欢迎大家点赞收藏+关注
文章目录
- 栈
-
- 1. 栈的概念及结构
- 2. 栈的实现
-
- 2.1 初始化栈
- 2.2 入栈
- 2.3 检测栈是否为空
- 2.4 出栈
- 2.5 获取栈顶元素
- 2.6 获取栈中有效元素个数
- 2.7 销毁栈
- 3. 接口测试
- 队列
-
- 1. 队列的概念及结构
- 2. 队列的实现
-
- 2.1 初始化队列
- 2.2 入队列
- 2.3 检测队列是否为空
- 2.4 出队列
- 2.5 获取队列头部元素
- 2.6 获取队列队尾元素
- 2.7 获取队列中有效元素个数
- 2.8 销毁队列
- 3. 接口测试
- 4. 拓展——环形队列
栈
1. 栈的概念及结构
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈。入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。
2. 栈的实现
栈一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
首先创建两个文件来实现栈：
- Stack.h（节点的声明、接口函数声明、头文件的包含）
- Stack.c（栈接口函数的实现）
接着创建 test.c 文件来测试各个接口
如图：
Stack.h 文件内容如下：
#pragma once
#include接下来，我们在 Stack.c 文件中实现各个接口函数。
2.1 初始化栈
对栈进行置空。
void STInit(ST* pst)
{
assert(pst);
pst->a = NULL;
pst->top = 0;
pst->capacity = 0;
}
2.2 入栈
判断扩容，然后直接尾插即可。
void STPush(ST* pst, STDataType x)
{
assert(pst);
if (pst->capacity == pst->top)
{
STDataType NewCapacity = (pst->capacity == 0 ? 4 : (pst->capacity) * 2);
STDataType* tmp = (STDataType*)realloc(pst->a, NewCapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
pst->a = tmp;
pst->capacity = NewCapacity;
}
pst->a[pst->top++] = x;
}
2.3 检测栈是否为空
栈为空返回 ture，否则返回 false。
bool STEmpty(ST* pst)
{
return pst->top == 0;
}
2.4 出栈
断言检测栈是否为空，非空直接尾删即可。
void STPop(ST* pst)
{
assert(pst);
assert(!STEmpty(pst));
pst->top--;
}
2.5 获取栈顶元素
断言检测栈是否为空，非空返回栈顶元素。
STDataType STTop(ST* pst)
{
assert(pst);
assert(!STEmpty(pst));
return pst->a[pst->top - 1];
}
2.6 获取栈中有效元素个数
返回栈中元素个数。
int STSize(ST* pst)
{
assert(pst);
return pst->top;
}
2.7 销毁栈
释放动态开辟好的内存，并对数据进行置空。
void STDestroy(ST* pst)
{
assert(pst);
free(pst->a);
pst->a = NULL;
pst->top = pst->capacity = 0;
}
注：在每个接口函数中一定要合理地使用assert函数断言防止对空指针的引用。
3. 接口测试
test.c 文件内容如下：
#include "Stack.h"
#include 运行结果：
队列
1. 队列的概念及结构
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。 进行插入操作的一端称为队尾，进行删除操作的一端称为队头。队列中的数据元素遵循先进先出FIFO（First In First Out）的原则。
- 入队列：队列的插入操作叫做入队列。从队尾插入数据。
- 出队列：队列的删除操作叫做出队列。从对头删除数据。
2. 队列的实现
队列也可以用数组或者链表来实现，相对而言使用链表结构的实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
首先创建两个文件来实现队列：
- Queue.h（节点的声明、接口函数声明、头文件的包含）
- Queue.c（队列接口函数的实现）
接着创建 test.c 文件来测试各个接口
如图：
Queue.h 文件内容如下：
#pragma once
#include接下来，我们在 Queue.c 文件中实现各个接口函数。
2.1 初始化队列
对队列进行置空。
void QueueInit(Queue* pq)
{
assert(pq);
pq->phead = NULL;
pq->ptail = NULL;
pq->size = 0;
}
2.2 入队列
在堆上申请一个节点，判断是否为第一个节点。如果是第一个节点，就让队列的头尾指针指向该节点；如果不是第一个节点，直接尾插即可。
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QNode* NewNode = (QNode*)malloc(sizeof(QNode));
if (NewNode == NULL)
{
perror("malloc fail");
return;
}
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++;
}
2.3 检测队列是否为空
队列为空返回 ture，否则返回 false。
int QueueEmpty(Queue* pq)
{
assert(pq);
return pq->size == 0;
}
2.4 出队列
断言检测队列是否为空，非空直接头删，最后判断删除的是否是最后一个节点。如果是最后一个节点，需要将尾指针置空。
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
QNode* next = pq->phead->next;
free(pq->phead);
pq->phead = next;
pq->size--;
if (pq->size == 0)
{
pq->ptail = NULL;
}
}
2.5 获取队列头部元素
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->phead->data;
}
2.6 获取队列队尾元素
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->ptail->data;
}
2.7 获取队列中有效元素个数
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
2.8 销毁队列
将队列中的所有元素都执行出队列操作即可。
void QueueDestroy(Queue* pq)
{
assert(pq);
while (!QueueEmpty(pq))
{
QueuePop(pq);
}
}
注：在每个接口函数中一定要合理地使用assert函数断言防止对空指针的引用。
3. 接口测试
test.c 文件内容如下：
#include "Queue.h"
#include 运行结果：
4. 拓展——环形队列
实际中我们有时还会使用一种队列叫循环队列。
循环队列是一种线性数据结构，其操作表现基于 先进先出 原则，并且 队尾被连接在队首之后以形成一个循环。它也被称为 “环形缓冲器”。
注意：
（1）为了避免 空 和 满 混淆，无法区分，那么可以 多开一个空间。
（2）当
head == tail时，就为 空。（3）当 tail 的下一个位置是 head 时，就是满。
循环队列如果用链表实现的话，不容易找尾，所以一般我们用数组来实现。
