【数据结构初阶】栈和队列（C语言实现+图解）
文章目录
- 栈
-
- 栈的概念及结构
- 栈的实现
-
-
- 栈结构体定义
- 栈的接口
- 栈的初始化
- 栈的销毁
- 入栈
- 出栈
- 取栈顶元素
- 判断栈是否为空
- 栈的元素个数
-
- 完整代码
- 队列
-
- 队列的概念及结构
- 队列的实现
-
-
- 队列结构体定义
- 队列的接口
- 队列的初始化
- 队列的销毁
- 入队
- 出队
- 取队头和队尾元素
- 判断队列是否为空
- 统计队列元素个数
-
- 完整代码
栈
栈的概念及结构
栈：是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈： 从栈顶放入数据的操作被称为压栈，也可以叫做进栈、入栈。
出栈： 删除栈顶数据的操作被称为出栈，也可以叫做弹栈。
栈的实现
栈的实现一般可以使用数组或者链表实现。那如何选择呢？我们来分析一下。
链表栈： 如果选择单链表的话，我们因该选头结点当栈顶，尾结点当栈底，否则，每次存取数据的时候都必须遍历链表，其次，需要频繁的申请结点，对内存会有一定损耗。所以如果选链表栈的话，推荐选择双向链表会比较好点。
数组栈： 对于数组栈来说，访问栈顶的时间复杂度为O(1)，虽动态增容时会有一定的消耗，在增容次数不会很多。所以相比链表栈，数组栈更优。
所以下面我们用顺序表来实现栈
栈结构体定义
结构如下
typedef int STDataType;
typedef struct Stack
{
STDataType* a;//指向为栈开辟的空间
int top;//指向栈顶，相当于顺序表中的size
int capacity;//容量
}ST;
栈的接口
栈实现的接口主要有以下几个：
//初始化
void StackInit(ST* ps);
//销毁
void StackDestroy(ST* ps);
//入栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);
//取栈顶元素
STDataType StackTop(ST* ps);
//判空
bool StackEmpty(ST* ps);
//计算栈中元素个数
int StackSize(ST* ps);
栈的初始化
代码实现：
//初始化
void StackInit(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->top = ps->capacity = 0;
}
注意：top可以初始化为0，也可以初始化为-1
- 若为0，则
top为栈顶元素的下一个位置，其值代表元素个数 - 若为-1，则
top为当前栈顶元素的下标，其值+1才代表元素个数
栈的销毁
为了防止内存泄露，动态内存申请的空间一定要我们自己手动释放，养成一个良好的习惯。
//销毁
//销毁
void StackDestroy(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}
入栈
入栈就是在栈顶插入数据，在插入数据之前，我们需要考虑扩容的问题，当ps->top == ps->capacity的时候，就需要扩容了，扩容和顺序表一样每次扩一倍，这样可以减少扩容的次数，但同时可能会带来一定的空间浪费。
代码实现
//入栈
void StackPush(ST* ps, STDataType x)
{
assert(ps);
//需要判断栈是否满了,满了就要扩容
if (ps->top == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
ps->a = tmp;
ps->capacity = newcapacity;
}
ps->a[ps->top] = x;
ps->top++;
}
出栈
出栈就是删除栈顶的元素，也就是top-1指向的位置，所以我们只需将top减一操作即可。
我们在出栈的过程中还需注意一点，就是栈是否为空，如果为空，就不能进行操作
代码实现：
//出栈
void StackPop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
ps->top--;
}
取栈顶元素
因为栈顶元素的下标是top-1，所以我们只需返回top-1位置的元素即可。同时我们也需要注意栈是否为空
代码实现：
//取栈顶元素
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
判断栈是否为空
因为我们的top是初始化为0，其值代表栈中元素的个数，所以，当top == 0就代表栈空。
代码实现：
//判空
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
栈的元素个数
top就是栈中元素的个数，返回top即可
代码实现：
//计算栈中元素个数
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
完整代码
//初始化
void StackInit(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->top = ps->capacity = 0;
}
//销毁
void StackDestroy(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}
//入栈
void StackPush(ST* ps, STDataType x)
{
assert(ps);
//需要判断栈是否满了,满了就要扩容
if (ps->top == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
ps->a = tmp;
ps->capacity = newcapacity;
}
ps->a[ps->top] = x;
ps->top++;
}
//出栈
void StackPop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
ps->top--;
}
//取栈顶元素
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top - 1];
}
//判空
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
//计算栈中元素个数
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
队列
队列的概念及结构
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)的原则
队头： 进行删除操作的一端称为队头
队尾： 进行插入操作的一端称为队尾
入队列即在队尾插入数据，出队列则是在队头删除数据。
队列的实现
队列也可以使用数组和链表来实现，我们选择使用单链表来实现，只需进行头删和尾插，如果使用数组的话，那么每一次删头，我们都需要挪动数据，效率不高。
队列结构体定义
定义结构如下：
typedef int QDataType;
//结点
typedef struct QueueNode
{
struct Queue* next;
QDataType data;
}QNode;
//队列
typedef struct Queue
{
QNode* head;//记录链表的头
QNode* tail;//记录链表的尾
int size;//记录队列的元素个数
}Queue;
队列需要两个指针标识队头和队尾，以便管理队列的元素。而队列元素即结点用单链表的结构实现即可。把结点封装成一个结构体，队列再封装成一个结构体存入指向结点结构体的指针。
如果不定义Queue结构体或者是说不将 头尾指针 封装起来的也是可以的，不过这样我们在传参时就需要使用二级指针了。
void QueueInit(QNode** pphead, QNode* pptail);
队列的接口
队列实现的接口主要有以下几个：
//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestroy(Queue* pq);
//入队
void QueuePush(Queue* pq, QDataType x);
//出队
void QueuePop(Queue* pq);
//取队头元素
QDataType QueueFront(Queue* pq);
//取队尾元素
QDataType QueueBack(Queue* pq);
//判空
bool QueueEmpty(Queue* pq);
//计算队列大小
int QueueSize(Queue* pq);
队列的初始化
代码实现：
//初始化
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
pq->size = 0;
}
队列的销毁
代码实现：
//销毁
void QueueDestroy(Queue* pq)
{
assert(pq);
QNode* cur = pq->head;
while (cur)
{
QNode* del = cur;
cur = cur->next;
free(del);
}
pq->head = pq->tail = NULL;
}
初始化和销毁并没有传二级指针，因为传递的是队列结构体的地址，而两个头尾指针是封装在队列结构体里的。创建队列在函数外，所以传其地址就行，同时加上断言以防空指针。
入队
入队其实就是单链表尾插的操作，进行尾插需要判断链表为不为空。
为空时需要改变头尾指针的指向，不为空就不需要了。
代码实现：
//入队
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
//首先需要申请一个新结点
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
else
{
newnode->data = x;
newnode->next = NULL;
}
//队列为空
if (pq->tail == NULL)
{
pq->head = pq->tail = newnode;
}
//队列不为空
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
pq->size++;
}
出队
出队其实就是单链表头删的操作，进行头删时，需要注意链表是否为空，还需要考虑当链表只有一个结点的情况
代码实现：
//出队
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));//判断链表是否为空
//只有一个元素
if (pq->head->next == NULL)
{
free(pq->head);
pq->head = pq->tail = NULL;
}
//多个元素
else
{
QNode* del = pq->head;
pq->head = pq->head->next;
free(del);
del = NULL;
}
pq->size--;
}
取队头和队尾元素
取队头元素就是返回头结点的数据，取队尾元素就是返回尾结点的数据
代码实现：
//取队头元素
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->data;
}
//取队尾元素
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
判断队列是否为空
当pq->head==NULL且pq->tail==NULL则链表为空
代码实现：
//判空
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL && pq->tail == NULL;
}
统计队列元素个数
队列结构体中的size就是统计队列元素的个数
代码实现：
//计算队列中元素的个数
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
完整代码
//初始化
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
pq->size = 0;
}
//销毁
void QueueDestroy(Queue* pq)
{
assert(pq);
QNode* cur = pq->head;
while (cur)
{
QNode* del = cur;
cur = cur->next;
free(del);
}
pq->head = pq->tail = NULL;
}
//入队
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
//首先需要申请一个新结点
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
else
{
newnode->data = x;
newnode->next = NULL;
}
//队列为空
if (pq->tail == NULL)
{
pq->head = pq->tail = newnode;
}
//队列不为空
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
pq->size++;
}
//出队
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
//只有一个元素
if (pq->head->next == NULL)
{
free(pq->head);
pq->head = pq->tail = NULL;
}
//多个元素
else
{
QNode* del = pq->head;
pq->head = pq->head->next;
free(del);
del = NULL;
}
pq->size--;
}
//取队头元素
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->data;
}
//取队尾元素
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
//判空
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL && pq->tail == NULL;
}
//计算队列大小
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}