文章目录
一.栈
1.栈的基本概念
栈(stack)是只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入或删除操作，如图所示
栈顶（top) ：线性表允许进行插入删除的那一端。
栈底(bottom)： 固定的，不允许进行插入和删除的另一端。
空栈 ：不含任何元素的空表。
假设某个栈S=（a1,a2,a3,a4,a5,a6)，如图所示，则a1，为栈底元素，a6为栈顶元素。栈只能在栈顶进行插入和删除操作，进栈次序依次为a1,a2,a3,a4,a5,a6,而出栈次序为a6,a5,a4,a3,a2,a1。由此可见，栈的操作特性可以明显地概括为后进先出(Last In First Out,LIFO)。
栈也分为顺序栈和链栈（类似于顺序表和链表），栈的实现一般可以使用数组或链表，相对于链表结构，数组的结构更优，因为数组尾插时间复杂度O(1)要小于链表尾插时间复杂度O(n),下面重点讲解顺序栈的存储结构
2.栈的顺序存储结构
2.1顺序栈的实现
采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针（top)指示当前栈顶元素位置。
栈的顺序存储类型可描述为
静态分配：
#define maxsize 50
typedef int STDatatype;
typedef struct Stack{
STDatatype data[maxsize];
int top;
}Stack;
动态分配：
typedef int STDatatype;
typedef struct Stack {
STDatatype* a;
int capacity; //容量
int top; //栈顶指针
}Stack;
ps(在我上一篇线性表中有关于顺序表的静态分配和动态分配的区别，这里就不在过多描述。)
下面将会以动态分配的顺序栈为例讲解顺序栈的基本操作。
2.2顺序栈的基本操作
2.2.1.初始化
用malloc为数组ps->a开辟动态空间，数组长度为Init_size(4),top栈顶指针置为0。
void InitStack(Stack* ps) {
//assert断言，防止传入空指针
assert(ps);
ps->a = (STDatatype*)malloc(sizeof(STDatatype) * Init_size);
if (ps->a == NULL) {
perror("malloc false");
return;
}
ps->capacity = Init_size;
ps->top = 0;
}
2.2.2.判栈空
当栈顶指针top为0时，数组为空。
bool IsEmpty(Stack* ps) {
//assert断言，防止传入空指针
assert(ps);
return ps->top == 0;
}
2.2.3.入栈
入栈的时候我们要先考虑数组满的情况，如果数组满了，我们就要为数组扩容，如果我们直接让原来的指针ps->a指向扩容的数组地址，扩容失败ps->a就会直接变成空指针，扩容时我们先用一个指针tmp指向扩容后的数组地址，然后检查扩容是否成功，扩容失败直接return结束，扩容成功我们再将ps->a指针指向扩容后的数组地址。之后我们再将数据元素入栈，入栈时先存值，top指针再加一。
void pushStack(Stack* ps, STDatatype x) {
//assert断言，防止传入空指针
assert(ps);
//检查数组是否满
if (ps->top == ps->capacity) {
//扩容，扩容大小一般为原来的二倍
STDatatype* tmp = (STDatatype*)realloc(ps->a, sizeof(STDatatype) * ps->capacity * 2);
if (tmp == NULL) {
perror("realloc false");
return;
}
ps->a = tmp;
ps->capacity *= 2;
}
//入栈
ps->a[ps->top++] = x;
}
2.2.4.出栈
出栈时，如果是空栈就不再出栈，否则top指针减一
void popStack(Stack* ps) {
//assert断言，防止传入空指针
assert(ps);
//assert断言，如果数组为空，空数组不再出栈
assert(!IsEmpty(ps));
//出栈
ps->top--;
}
2.2.5.获取栈顶元素
获取栈顶元素时，如果是空栈就不再获取栈顶元素，否则top指针先减一，再返回栈顶元素
STDatatype gettopStack(Stack* ps) {
//assert断言，防止传入空指针
assert(ps);
//assert断言，防止数组为空，空数组不再获取栈顶元素
assert(!IsEmpty(ps));
return ps->a[ps->top-1];
}
2.2.6.销毁
销毁时先free（ps->a），然后指针置为空，再将容量和栈顶指针置为0。
void DestroyStack(Stack* ps) {
//assert断言，防止传入空指针
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = 0;
ps->top = 0;
}
2.2.7.测试用例
ps:以下测试用例仅供参考，可以尝试带入其他数据或调用其他函数来测试
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
int main() {
Stack s; //创建一个栈s
InitStack(&s); //初始化栈s
pushStack(&s, 1); //依次入栈1 2 3
pushStack(&s, 2);
pushStack(&s, 3);
while (!IsEmpty(&s)) { //依次出栈3 2 1
printf("%d ", getpopStack(&s));
popStack(&s);
}
pushStack(&s, 4); //依次入栈4 5
pushStack(&s, 5);
while (!IsEmpty(&s)) { //依次出栈5 4
printf("%d ", getpopStack(&s));
popStack(&s);
}
pushStack(&s, 6); //入栈6
while (!IsEmpty(&s)) { //出栈6
printf("%d ", getpopStack(&s));
popStack(&s);
}
DestroyStack(&s); //销毁栈s
return 0;
}
测试结果如下：
二.队列
1.队列的基本概念
队列（Queue)简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在队表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。这和我们日常生活中的排队一样，最早排队也是最早离队的，其操作特性是先进先出（First In First Out,FIFO).如图所示。
队头（Front）：允许删除的一端，又称队首。
队尾（Rear）：允许插入的一端。
空队列：不含有任何元素的空表。
队列和栈一样，队列的实现一般也可以使用数组或链表，而用数组实现的队列通常设计成循环队列，较为复杂（在我之后的一篇关于栈和队列练习题中有关于循环队列的题，我将在之后的文章中讲解，感兴趣的可以关注期待一下），这里重点讲解用链表实现的队列。
2.队列的链式存储结构
2.1链式队列的实现
队列的链式表示又称链队列，实际上是同时有一个队头指针和一个队尾指针的单链表。如图所示，队头指针指向队头，队尾指针指向队尾，即单链表的最后一个节点。
队列的链式存储类型可描述为
typedef int QDataType;
typedef struct QueueNode { //链式队列节点
struct QueueNode* next;
QDataType data;
}QueueNode;
typedef struct Queue { //链式队列
QueueNode* front; //队头指针
QueueNode* rear; //队尾指针
int size;
}Queue;
2.2链式队列的基本操作
2.2.1.初始化
队列初始化直接让队头指针和队尾指针指向空就可以，队长设置为0。
void QueueInit(Queue* pq){
//assert断言，防止传入空指针
assert(pq);
pq->front = pq->rear = NULL;
pq->size = 0;
}
2.2.2.判断为空
队空可以用队长size为0或者队头指针等于队尾指针来判断。
bool QueueIsEmpty(Queue* pq) {
//assert断言，防止传入空指针
assert(pq);
return pq->size == 0;
//也可以 pq->front==pq->rear 队头指针等于队尾指针
}
2.2.3.销毁
销毁时借助一个索引指针cur依次将链表的每个节点释放置为空，然后队头指针，队尾指针置为空，队长置为0。
void QueueDestroy(Queue* pq) {
//assert断言，防止传入空指针
assert(pq);
QueueNode* cur = pq->front;
while (cur) {
QueueNode* tail = cur->next;
free(cur);
cur = tail;
}
pq->front = pq->rear = NULL;
pq->size = 0;
}
2.2.4.获取队长
获取队长直接返回size即可
int Queuesize(Queue* pq) {
//assert断言，防止传入空指针
assert(pq);
return pq->size;
}
2.2.5.入队
入队时先建立新节点，然后这里要分两种情况，如果入队第一个元素时，直接让队头指针队尾指针指向新节点，不是第一个元素时，将新节点链接在队尾指针后，然后队长加一。
void QueuePush(Queue* pq,QDataType x) {
//assert断言，防止传入空指针
assert(pq);
//建立新节点
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (newnode == NULL) {
perror("malloc false");
return;
}
newnode->data = x;
newnode->next = NULL;
if (pq->front == NULL) {
pq->front = pq->rear = newnode;
}
else {
pq->rear->next = newnode;
pq->rear = newnode;
}
pq->size++;
}
2.2.6.出队
出队时如果是空队列不再出队，不是空队列也要考虑两种情况，当只剩下一个节点时，即队头指针等于队尾指针，直接让队头指针和队尾指针置为空就行。另一种情况就先设置一个索引指针tail指向队头指针后一个，然后释放队头指针，队头指针再指向后一个节点。
void QueuePop(Queue* pq) {
//assert断言，防止传入空指针
assert(pq);
//assert断言，防止队列为空，空队列不再出队
assert(!QueueIsEmpty(pq));
if (pq->front == pq->rear) {
free(pq->front);
pq->front = pq->rear = NULL;
}
else {
QueueNode* tail = pq->front->next;
free(pq->front);
pq->front = tail;
}
pq->size--;
}
2.2.7.获取队头元素
队不为空时，直接返回队头元素
QDataType GetQueueFront(Queue* pq) {
//assert断言，防止传入空指针
assert(pq);
//assert断言，防止队列为空，空队列不再获取队头元素
assert(!QueueIsEmpty(pq));
return pq->front->data;
}
2.2.8.获取队尾元素
队不为空时，直接返回队尾元素
QDataType GetQueueRear(Queue* pq) {
//assert断言，防止传入空指针
assert(pq);
//assert断言，防止队列为空，空队列不再获取队尾元素
assert(!QueueIsEmpty(pq));
return pq->rear->data;
}
2.2.9.测试用例
ps:以下测试用例仅供参考，可以尝试带入其他数据或调用其他函数来测试
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
int main() {
Queue q; //创建队列q
QueueInit(&q); //初始化队列q
QueuePush(&q, 1); //依次入队1 2 3 4 5
QueuePush(&q, 2);
QueuePush(&q, 3);
QueuePush(&q, 4);
QueuePush(&q, 5);
while (!QueueIsEmpty(&q)) { //依次出队1 2 3 4 5
printf("%d ", GetQueueFront(&q));
QueuePop(&q);
}
QueueDestroy(&q); //销毁队列q
return 0;
}
测试结果如下：
以上就是关于栈和队列的讲解，如果哪里有错的话，可以在评论区指正，也欢迎大家一起讨论学习，如果对你的学习有帮助的话，点点赞关注支持一下吧！！！
扫一扫
24万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
