0.前言
您好,这里是limou3434的一篇个人博文,感兴趣的话您也可以看看我的其他文章。
本次我给您带来的内容是栈和队列在C语言中的实现。在本次内容中,如果您对我之前写的“有关C语言内的顺序表和链表实现”比较清楚的话,那么本次分享的知识对您来说易如反掌(因为实际上,本文实现的栈和队列不过是顺序表和链表的特殊情况罢了)
1.栈基础
1.1.栈的基本概念
- 栈是一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。
- 栈的插入元素操作叫“入栈(或者压栈、进栈)”
- 栈的移除元素操作叫“出栈”,出栈必须从最靠近栈出口的一端出元素
- 进行进栈出栈操作的一端称为栈顶,另一端称为栈底。栈中的每一个数据元素都遵守“LIFO(Last In First Out“后进先出”)”原则。
- 栈的实现可以用顺序表和链表,分别叫作“顺序栈和”和“链式栈”。其中顺序表实现的栈比较常见(链式栈的实现需要注意把单链表的首节点作为栈顶,尾节点作为栈底。对于链式栈,入栈相当于给单链表头插,出栈就相当于给单链表头删)
- DFS是深度优先遍历(会用到递归/栈)
1.2.栈的基本接口
1.2.1.对于栈来说,栈主要有以下的接口
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <stdbool.h>
//> 栈的实现
//> 1.支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
STDataType* _a;
int _top; // 栈顶
int _capacity; // 容量
}Stack;
//> 2.初始化栈
void StackInit(Stack* ps);
//> 3.入栈
void StackPush(Stack* ps, STDataType data);
//> 4.出栈
void StackPop(Stack* ps);
//> 5.获取栈顶元素
STDataType StackTop(Stack* ps);
//> 6.获取栈中有效元素个数
int StackSize(Stack* ps);
//> 7.检测栈是否为空,如果为空返回非零,如果不为空返回0
int StackEmpty(Stack* ps);
//> 8.销毁栈
void StackDestroy(Stack* ps);
1.2.2.栈接口的具体实现
//> 2.初始化栈
void StackInit(Stack* ps)
{
//1.检查指针有效性
assert(ps);
//2.初始化栈的信息
ps->_a = (STDataType*)malloc(sizeof(STDataType) * 4);//先给上4个空间,并且检查是否申请成功
if (!ps->_a)
{
perror("malloc fail!\n");
return;
}
ps->_top = 0;//这个赋值也可以是-1
ps->_capacity = 4;
}
//> 3.入栈
void StackPush(Stack* ps, STDataType data)
{
//1.检查指针有效性
assert(ps);
//2.检查栈容量是否满了
if (ps->_capacity == ps->_top)
{
STDataType* cache = (STDataType*)realloc(ps->_a, sizeof(STDataType) * ((ps->_capacity) * 2));
if (!cache)
{
printf("realloc fail!\n");
exit(-1);
}
ps->_a = cache;
ps->_capacity = ps->_capacity * 2;
}
//3.入栈并且更新栈的数据
ps->_a[ps->_top] = data;
ps->_top++;
}
//> 4.出栈
void StackPop(Stack* ps)
{
//1.检查指针有效性
assert(ps);
//2.检查栈是否有元素
assert(ps->_top > 0);
//3.直接利用下标“删除”元素,注意栈内存储元素的“实际下标”比“_top”的数值小1
ps->_top--;
}
//> 5.获取栈顶元素
STDataType StackTop(Stack* ps)
{
//1.检查指针的有效性
assert(ps);
//2.检查栈是否还有元素
assert(ps->_top > 0);
//3.取出栈顶元素
return ps->_a[ps->_top - 1];
}
//> 6.获取栈中有效元素个数
int StackSize(Stack* ps)
{
//1.检查指针的有效性
assert(ps);
//2.获取元素个数
return ps->_top;
}
//> 7.检测栈是否为空,如果为空返回非零,如果不为空返回0
int StackEmpty(Stack* ps)
{
assert(ps);
return (ps->_top == 0);
}
//> 8.销毁栈
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->_a);
ps->_a = NULL;
ps->_capacity = ps->_top = 0;
}
1.3.栈的测试用例
void test_1()
{
Stack st1;//创建一个栈结构体
StackInit(&st1);//初始化这个栈
StackPush(&st1, 1);//压栈
StackPush(&st1, 2);//压栈
StackPush(&st1, 3);//压栈
StackPush(&st1, 4);//压栈
StackPush(&st1, 5);//压栈
printf("<栈顶>\n");
while (!StackEmpty(&st1))//只要栈不为空就进入循环
{
printf("%3d\n", StackTop(&st1));//取出栈顶元素并且打印
StackPop(&st1);//删除栈顶元素
}
printf("<栈底>\n");
//StackPop(&st1);//非法删除
//StackPop(&st1);//非法取栈顶元素
StackDestroy(&st1);//销毁栈结构体
}
2.队列基础
2.1.队列的基本概念
- 队列是一种特殊的线性表,其只允许在一端进行插入元素操作,而另一端进行删除元素操作。
- 队列的插入元素操作叫“入队尾”
- 队列的移除元素操作叫“出队头”
- 进行出队的一端称为队头,进行入队称为队尾。队列中的每一个数据元素都遵守“FIFO(First In First Out“先近后出”)”原则。
- 队列的实现可以用顺序表和链表,其中链表实现的队列比较常见
- 队列最经典的应用是抽号机,对于特定序列的数据入队,其出队列也必然是按照原顺序的
- BFS是广度优先遍历(会用到队列)
2.2.队列的基本接口
2.2.1.对于队列来说,队列主要有以下得接口
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <stdbool.h>
//> 队列的实现
//> 1.链式结构:表示队列的一个元素
typedef int QDataType;
typedef struct QListNode
{
struct QListNode* _pNext;
QDataType _data;
}QNode;
//> 2.队列的结构
typedef struct Queue
{
QNode* _front; //队头
QNode* _rear; //队尾
}Queue;
//> 3.初始化队列
void QueueInit(Queue* q);
//> 4.队尾入队列
void QueuePush(Queue* q, QDataType data);
//> 5.队头出队列
void QueuePop(Queue* q);
//> 6.获取队列头部元素
QDataType QueueFront(Queue* q);
//> 7.获取队列队尾元素
QDataType QueueBack(Queue* q);
//> 8.获取队列中有效元素个数
int QueueSize(Queue* q);
//> 9.检测队列是否为空,如果为空返回非零结果,如果非空返回0
int QueueEmpty(Queue* q);
//> 10.销毁队列
void QueueDestroy(Queue* q);
2.2.2.队列接口的具体实现
//> 3.初始化队列
void QueueInit(Queue* q)
{
//1.检查指针的有效性
assert(q);
//2.初始化队列(队尾队头都置为空)
q->_front = q->_rear = NULL;
}
//> 4.队尾入队列(链表尾插)
void QueuePush(Queue* q, QDataType data)
{
//1.检查指针的有效性
assert(q);
//2.先申请一个链表节点并且存储好数据
QNode* cache = (QNode*)malloc(sizeof(QNode));
if (!cache)
{
perror("malloc fail\n");
exit(-1);
}
cache->_data = data;
cache->_pNext = NULL;
//3.开始尾插
if (q->_rear == NULL)//如果队列为空
{
q->_front = q->_rear = cache;
}
else
{
q->_rear->_pNext = cache;
q->_rear = cache;//改变队列的队尾标记,形成新的队尾
}
}
//> 5.队头出队列(链表头删)
void QueuePop(Queue* q)
{
//1.检查指针有效性
assert(q);
assert(q->_front);
//2.开始出数据
//2.1.处理特殊情况(只剩一个节点)
if (q->_front == q->_rear)
{
free(q->_front);
q->_front = q->_rear = NULL;
return;
}
//2.2.处理一般情况
QNode* delNode = q->_front;
q->_front = q->_front->_pNext;
free(delNode);
}
//> 6.获取队列头部元素
QDataType QueueFront(Queue* q)
{
//1.检查指针的有效性
assert(q);
assert(q->_front);
//2.返回队头的值
return q->_front->_data;
}
//> 7.获取队列队尾元素
QDataType QueueBack(Queue* q)
{
;
}
//> 8.获取队列中有效元素个数(这里也可以让队列结构体多加一个size成员)
int QueueSize(Queue* q)
{
//1.检查指针的有效性
assert(q);
//2.循环计数,返回有效元素个数
int size = 0;
QNode* cur = q->_front;
while (cur)
{
size++;
cur = cur->_pNext;
}
return size;
}
//> 9.检测队列是否为空,如果为空返回非零结果,如果非空返回0
int QueueEmpty(Queue* q)
{
//1.检查指针的有效性
assert(q);
//2.检测队列是否为空
return q->_front == NULL;
}
//> 10.销毁队列
void QueueDestroy(Queue* q)
{
//1.检查指针的有效性
assert(q);
//2.开始销毁
QNode* cur = q->_front;
while (cur)
{
QNode* next = cur->_pNext;
free(cur);
cur = next;
}
q->_front = q->_rear = NULL;
}
2.3.队列的测试用例
void test_2()
{
Queue q;
QueueInit(&q);//初始化队列
QueuePush(&q, 5);//入队尾
QueuePush(&q, 4);//入队尾
QueuePush(&q, 3);//入队尾
QueuePush(&q, 2);//入队尾
QueuePush(&q, 1);//入队尾
printf("队头->");
while (!QueueEmpty(&q))//若为非空队列则进入循环
{
printf("%d->", QueueFront(&q));//取出队头,并且打印
QueuePop(&q);
}
printf("队尾");
//QueueFront(&q);//非法取出队头
//QueuePop(&q);//非法删除队头
QueueDestroy(&q);
}
3.栈与队列oj题目
这里有几道题目可供你一做,我也提供了一些比较经典的解法,你也可以看看其他解友的代码,他们的写得要比我更加高效可用得多
3.1.有效的括号力扣
3.2.栈模拟队列力扣
3.3.队列模拟栈力扣
4.总结
-
总结一下,本次我给您带来了
- 1.有关栈的基础概念以及具体实现
- 2.有关队列的基础概念以及具体实现
-
也许看到这里您也许就会明白为什么我开头会说“本文实现的栈和队列不过是顺序表和链表的特殊情况罢了”这句话的原因了,您只需要记住Last In First Ou和First In First Out这两个原则,那么实现栈和队列并不难,这两者在日后的学习中是非常有用的。具体情况还请等待我后续的内容,当然您也可以去Google一下,相信您一定能获得比我这里更多的内容。
-
最后,愿与君共勉。