本篇博客来梳理栈和队列基本概念以及一道经典OJ题，题目已插入超链接，点击即可跳转~
一、栈的相关概念
1．栈
一种特殊的线性表，只允许在固定的一端插入和删除元素，栈中的数据遵循后进先出原则
（1）栈顶：进行数据插入和删除操作的一端
（2）栈底：栈顶的另一端
2．压栈：栈的插入操作
3．出栈：栈的删除操作
4．栈的实现：用数组较优，原因是数组尾插代价比较小
（1）Stack.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
STDataType* _a;
int _top; // 栈顶
int _capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
bool StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);
（2）Stack.c
#include"Stack.h"
void StackInit(Stack* ps)// 初始化栈
{
assert(ps);
ps->_a = NULL;
ps->_top = 0;
ps->_capacity = 0;
}
void StackPush(Stack* ps, STDataType data)//入栈(数组的尾插)
{
assert(ps);
if (ps->_capacity == ps->_top)
{
int newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->_a,newcapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("malloc failed!");
return;
}
ps->_a = tmp;
ps->_capacity = newcapacity;
}
ps->_a[ps->_top] = data;
ps->_top=ps->_top + 1;
}
void StackPop(Stack* ps)//出栈（去掉数组最后一个元素）
{
assert(ps);
assert(ps->_top > 0);
ps->_top--;
}
STDataType StackTop(Stack* ps)//获取栈顶元素
{
assert(ps);
assert(ps->_top);
return ps->_a[ps->_top-1];
}
int StackSize(Stack* ps)//获取栈中有效元素个数
{
assert(ps);
return ps->_top;
}
bool StackEmpty(Stack* ps)// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
{
assert(ps);
return ps->_capacity == 0;
}
void StackDestroy(Stack* ps)//销毁栈
{
assert(ps);
ps->_capacity = 0;
ps->_top = 0;
free(ps->_a);
ps->_a = NULL;
}
二、队列的相关概念
1．队列
一种特殊的线性表，只允许在一端插入数据，在另一端删除数据，栈中的元素遵循先进先出的原则
2．队头（对应链表头节点）：出队列的一侧
3．队尾（对应链表尾节点）：入队列的一侧
4．队列的实现：用链表较优，原因是数据出队列需要头删，数组效率较低
（1）Queue.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
// 链式结构：表示队列
typedef int QDataType;
typedef struct QListNode
{
struct QListNode* next;
QDataType data;
}QNode;
// 队列的结构
typedef struct Queue
{
QNode* phead;
QNode* ptail;
int size;
}Queue;
// 初始化队列
void QueueInit(Queue* pq);
// 队尾入队列（尾插）
void QueuePush(Queue* pq, QDataType data);
// 队头出队列（头删）
void QueuePop(Queue* pq);
// 获取队列头部元素
QDataType QueueFront(Queue* pq);
// 获取队列队尾元素
QDataType QueueBack(Queue* pq);
// 获取队列中有效元素个数
int QueueSize(Queue* pq);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* pq);
// 销毁队列
void QueueDestroy(Queue* pq);
（2）Queue.c
#include"Queue.h"
// 初始化队列
void QueueInit(Queue* pq)
{
assert(pq);
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
// 队尾入队列
void QueuePush(Queue* pq, QDataType data)
{
assert(pq);
if (pq->phead == NULL)//空队列
{
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("malloc failed!");
return;
}
newnode->next = NULL;
newnode->data = data;
pq->phead = newnode;
pq->ptail = pq->phead;
pq->size++;
}
else
{
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("malloc failed!");
return;
}
newnode->next = NULL;
newnode->data = data;
pq->ptail->next = newnode;
pq->ptail = newnode;
pq->size++;
}
}
// 队头出队列（头删）
void QueuePop(Queue* pq)
{
assert(pq);
if (pq->phead->next == NULL)//只有一个节点
{
free(pq->phead);
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
else
{
QNode* del = pq->phead;
pq->phead = pq->phead->next;
free(del);
del = NULL;
pq->size--;
}
}
// 获取队列头部元素
QDataType QueueFront(Queue* pq)
{
assert(pq);
return pq->phead->data;
}
// 获取队列队尾元素
QDataType QueueBack(Queue* pq)
{
assert(pq);
return pq->ptail->data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* pq)
{
return pq->size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* pq)
{
if (pq->size == 0)
{
return 1;
}
else
{
return 0;
}
}
// 销毁队列
void QueueDestroy(Queue* pq)
{
QNode* pcur = pq->phead;
while (pcur)
{
QNode* del = pcur;
pcur = pcur->next;
free(del);
del = NULL;
}
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
三、经典OJ：有效的括号
1、题目描述
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
(1)左括号必须用相同类型的右括号闭合。
(2)左括号必须以正确的顺序闭合。
(3)每个右括号都有一个对应的相同类型的左括号。
2、题目分析
（1）C语言的限制
由于C语言不直接提供栈，因此需要把我们自己实现的栈粘贴到解决方案当中
（2）思路分析
- 第一步：遇到的左括号全部入栈
- 第二步：如果遇到右括号，则把栈顶的左括号出栈，拿出来和右括号匹配
（3）代码实现
如果用C语言实现，请记得在本函数上方粘贴自己实现好的栈，在本函数中才可以调用相关接口~
bool isValid(char* s)
{
Stack stack;
StackInit(&stack);
while(*s!='\0')
{
if(*s=='('||*s=='['||*s=='{')
{
StackPush(&stack,*s);//左括号入栈
}
else//此时*s是右括号
{
if(stack._top == 0)//此时栈里面没有左括号
{
return false;
}
STDataType left=StackTop(&stack);//取出栈顶元素进行配对
if((left=='('&&*s!=')')
||(left=='['&&*s!=']')
||(left=='{'&&*s!='}'))
{
return false;
}
else//配对成功，出栈
{
StackPop(&stack);
}
}
s++;
}
if(stack._top>0)
{
return false;
}
return true;
}
