栈和队列详解
- 1 栈
- 1.1 栈的概念及结构
- 1.2 栈的实现
- 1.3 支持动态增长的栈
- 1.3.1 结构声明
- 1.3.2 栈的初始化和销毁
- 1.3.3 入栈和出栈操作
- 1.3.4 栈的判空和元素个数
- 2 队列
- 2.1 队列的概念及结构
- 2.2 队列的实现
- 2.3 链表实现队列
- 2.3.1 结构声明
- 2.3.2 队列的初始化和销毁
- 2.3.3 队列入队和出队
- 2.3.4 队列判空和获取元素个数
- 总结
1 栈
1.1 栈的概念及结构
栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
对栈有两种操作：
插入操作：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。(本篇博客我们就叫入栈吧)
删除操作：栈的删除操作叫做出栈。出数据也在栈顶。（本篇博客我们叫出栈）
1.2 栈的实现
栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
数组实现：
静态数组栈结构：
typedef int STDataType;
#define N 10
typedef struct Stack
{
STDataType a[N];
int top; // 栈顶
}Stack;
本图主要展示了由静态数组实现的栈，但是静态数组实现的栈并不实用，我们本篇博客主要实现的是支持动态增长的栈。
1.3 支持动态增长的栈
1.3.1 结构声明
// 支持动态增长的栈
#define DEFAULT_CAPACITY 4 //默认(初始)容量
typedef int STDataType;//栈存储的数据类型(这里为int)
typedef struct Stack
{
STDataType* a;
int top; // 栈顶
int capacity; // 容量
}Stack;
1.3.2 栈的初始化和销毁
函数声明：
// 初始化栈
void StackInit(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);
函数实现：
void StackInit(Stack* ps)
{
assert(ps);
//先给数组开辟一个初始容量
ps->a = (STDataType*)malloc(sizeof(STDataType) * DEFAULT_CAPACITY);
if (ps->a == NULL)
{
perror("malloc failed");
exit(-1);
}
ps->capacity = DEFAULT_CAPACITY;
ps->top = -1;
}
void StackDestroy(Stack* ps)
{
assert(ps);
ps->capacity = 0;
ps->top = -1;
free(ps->a);
}
需要注意的点：我们的栈顶从top是-1开始的，用于保证栈顶元素的下标与top相同，但是栈的元素个数就是了top+1了。
1.3.3 入栈和出栈操作
函数声明：
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
函数实现：
void StackPush(Stack* ps, STDataType data)
{
assert(ps);
//入栈之前先检查，栈是否满了，满了就需要扩容后再入栈
if (ps->top + 1 == ps->capacity)
{
STDataType* tmp = realloc(ps->a, sizeof(STDataType) * (ps->capacity) * 2);
if (tmp == NULL)
{
perror("realloc failed");
exit(-1);
}
ps->a = tmp;
ps->capacity *= 2;
}
(ps->top)++;
ps->a[ps->top] = data;
}
void StackPop(Stack* ps)
{
assert(ps);
assert(ps->top != -1);
(ps->top)--;
}
STDataType StackTop(Stack* ps)
{
assert(ps);
return ps->a[ps->top];
}
需要注意的是，我们这里的出栈函数分成了两个来写，一个只删除栈顶元素，一个只获取栈顶元素。这里写成一个函数也是可以的，即出栈函数，删除栈顶元素并返回该栈顶元素。
1.3.4 栈的判空和元素个数
函数声明：
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回true，如果不为空返回false
bool StackEmpty(Stack* ps);
函数实现:
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
assert(ps);
return ps->top + 1;
}
// 检测栈是否为空
bool StackEmpty(Stack* ps)
{
assert(ps);
return (ps->top == -1);
}
2 队列
2.1 队列的概念及结构
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出
FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头。
2.2 队列的实现
队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头部出数据，需要整体移动数据，效率会比较低。
2.3 链表实现队列
2.3.1 结构声明
//队列声明
typedef int QNodeDataType;
typedef struct QNode
{
QNodeDataType x;
struct QNode* next;
}QNode;
typedef struct Queue
{
QNode* head;//头指针
QNode* tail;//尾指针
size_t size;
}Queue;
2.3.2 队列的初始化和销毁
函数声明
// 初始化队列
void QueueInit(Queue* q);
// 销毁队列
void QueueDestroy(Queue* q);
函数实现：
// 初始化队列
void QueueInit(Queue* q)
{
assert(q);
q->head = q->tail = NULL;
q->size = 0;
}
// 销毁队列
void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->head;
while (cur)
{
QNode* tmp = cur;
cur = cur->next;
free(tmp);
}
q->head = q->tail = NULL;
q->size = 0;
}
2.3.3 队列入队和出队
函数声明：
// 队尾入队列
void QueuePush(Queue* q, QNodeDataType data);
// 队头出队列
void QueuePop(Queue* q);
// 获取队列头部元素
QNodeDataType QueueFront(Queue* q);
// 获取队列队尾元素
QNodeDataType QueueBack(Queue* q);
函数实现：
// 队尾入队列
void QueuePush(Queue* q, QNodeDataType data)
{
assert(q);
QNode* newNode = (QNode*)malloc(sizeof(QNode));
if (newNode == NULL)
{
perror("malloc failed");
exit(-1);
}
newNode->next = NULL;
newNode->x = data;
if (q->tail == NULL)
{
q->head = q->tail = newNode;
}
else
{
q->tail->next = newNode;
q->tail = q->tail->next;
}
q->size++;
}
// 队头出队列
void QueuePop(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
if (q->head->next == NULL)
{
free(q->head);
q->head = q->tail = NULL;
}
else
{
QNode* tmp = q->head;
q->head = q->head->next;
free(tmp);
}
q->size--;
}
// 获取队列头部元素
QNodeDataType QueueFront(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
return q->head->x;
}
// 获取队列队尾元素
QNodeDataType QueueBack(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
return q->tail->x;
}
同理，这里的功能也是分开写的，也可以合并起来写。
2.3.4 队列判空和获取元素个数
函数声明：
// 获取队列中有效元素个数
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回true，如果非空返回false
bool QueueEmpty(Queue* q);
函数实现：
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
assert(q);
return q->size;
}
// 检测队列是否为空
bool QueueEmpty(Queue* q)
{
assert(q);
return (q->size == 0);
}
总结
栈和队列是相对比较简单的两个结构了，他们多用于其他复杂结构的子结构(后期会讲到)。下一期会介绍几道它们的例题。
聊一下与本篇博客无关的内容，其实可以看到我停更了比较长的一段时间，主要原因是临近期末，复习去了，而且博主并不是计算机专业的，是自动化专业的，刚好这学期的课程比较多，所以复习内容也比较多，所以停更了比较长的时间，希望大家理解。这几天刚刚放假，会速度更新的。
