目录
一、栈stack
基本概念
基本操作
存储结构
二、队列Queue
基本概念
队列的基本操作
存储结构
三、栈的应用
栈在括号匹配中的应用
栈在表达式求值中的应用编辑
栈在递归中的应用
一、栈stack
基本概念
- 只允许在一端(栈顶top)进行插入或删除操作的受限的线性表
- 后进先出(LIFO)
基本操作
- InitStack(&S): 初始化一个空栈SStackEmpty(S):判断一个栈是否为空，若栈为空则返回true，否则返回false。
- Push(&S,x):进栈，若S未满，则将x加入使之成为新栈顶。
- Pop(&S,&x): 出栈，若非空，则弹出栈顶元素，并用x返回。
- GetTop(S,&x): 读栈顶元素，若栈非空则用x返回栈顶元素
- ClearStack(&S):):销毁栈，并释放S占用的内存空间。
存储结构
【顺序存储结构(顺序栈)】
#define MaxSize 10 //定义栈中元素的最大个数
typedef struct{
ElemType data[MaxSize]; //静态数组存放栈中元素
int top; //栈顶元素
}SqStack;
void testStack(){
SqStack S; //声明一个顺序栈(分配空间)
//连续的存储空间大小为 MaxSize*sizeof(ElemType)
}【顺序栈的基本操作】
#define MaxSize 10 //定义栈中元素的最大个数
typedef struct{
ElemType data[MaxSize]; //静态数组存放栈中元素
int top; //栈顶元素
}SqStack;
//初始化栈
void InitStack(SqStack &S){
S.top = -1; //初始化栈顶指针
}
//判栈空
bool StackEmpty(SqStack S){
if(S.top == -1) //栈空
return true;
else //栈不空
return false;
}
//新元素进栈
bool Push(SqStack &S, ElemType x){
if(S.top == MaxSize - 1) //栈满
return false;
S.top = S.top + 1; //指针先加1
S.data[S.top] = x; //新元素入栈
/*
S.data[++S.top] = x;
*/
return true;
}
//出栈
bool Pop(SqStack &x, ElemType &x){
if(S.top == -1) //栈空
return false;
x = S.data[S.top]; //先出栈
S.top = S.top - 1; //栈顶指针减1
return true;
/*
x = S.data[S.top--];
*/
//只是逻辑上的删除，数据依然残留在内存里
}
//读栈顶元素
bool GetTop(SqStack S, ElemType &x){
if(S.top == -1)
return false;
x = S.data[S.top]; //x记录栈顶元素
return true;
}
void testStack(){
SqStack S; //声明一个顺序栈(分配空间)
InitStack(S);
//...
}- 进栈操作 ：栈不满时，栈顶指针先加1，再送值到栈顶元素。
S.data[S.top++] = x; - 出栈操作：栈非空时，先取栈顶元素值，再将栈顶指针减1。`x = S.data[–S.top];
- 栈空条件：S.top==-1
- 栈满条件：S.top==MaxSize-1
- 栈长：S.top+1
【共享栈】
- 共享栈--特殊的顺序栈
- 将栈底设计在共享空间的两端，栈顶向中间靠拢
#define MaxSize 10 //定义栈中元素的最大个数
typedef struct{
ElemType data[MaxSize]; //静态数组存放栈中元素
int top0; //0号栈栈顶指针
int top1; //1号栈栈顶指针
}ShStack;
//初始化栈
void InitSqStack(ShStack &S){
S.top0 = -1; //初始化栈顶指针
S.top1 = MaxSize;
}【链式存储结构(链栈)】
- 定义：采用链式存储的栈称为链栈。
- 优点：链栈的优点是便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情况。
- 特点：进栈和出栈都只能在栈顶一端进行(链头作为栈顶)
链表的头部作为栈顶，意味着：
- 1. 在实现数据"入栈"操作时，需要将数据从链表的头部插入；
- 2. 在实现数据"出栈"操作时，需要删除链表头部的首元节点；
因此，链栈实际上就是一个只能采用头插法插入或删除数据的链表;
栈的链式存储结构可描述为：
typedef struct Linknode{
ElemType data; //数据域
struct Linknode *next; //指针域
}*LiStack; //栈类型的定义
带头结点的链栈基本操作：
#include<stdio.h>
struct Linknode{
int data; //数据域
Linknode *next; //指针域
}Linknode,*LiStack;
typedef Linknode *Node; //结点结构体指针变量
typedef Node List; //结点结构体头指针变量
//1. 初始化
void InitStack(LiStack &L){ //L为头指针
L = new Linknode;
L->next = NULL;
}
//2.判栈空
bool isEmpty(LiStack &L){
if(L->next == NULL){
return true;
}
else
return false;
}
//3. 进栈(：链栈基本上不会出现栈满的情况)
void pushStack(LiStack &L, int x){
Linknode s; //创建存储新元素的结点
s = new Linknode;
s->data = x;
//头插法
s->next = L->next;
L->next = s;
}
//4.出栈
bool popStack(LiStack &L, int &x){
Linknode s;
if(L->next == NULL) //栈空不能出栈
return false;
s = L->next;
x = s->data;
L->next = L->next->next;
delete(s);
return true;
}
不带头结点的链栈基本操作：
#include<stdio.h>
struct Linknode{
int data; //数据域
Linknode *next; //指针域
}Linknode,*LiStack;
typedef Linknode *Node; //结点结构体指针变量
typedef Node List; //结点结构体头指针变量
//1.初始化
void initStack(LiStack &L){
L=NULL;
}
//2.判栈空
bool isEmpty(LiStack &L){
if(L == NULL)
return true;
else
teturn false;
}
//3.进栈
void pushStack(LiStack &L, int x){
Linknode s; //创建存储新元素的结点
s = new Linknode;
s->next = L;
L = s;
}
//4.出栈
bool popStack(LiStack &L, int &x){
Linknode s;
if(L = NULL) //栈空不出栈
return false;
s = L;
x = s->data;
L = L->next;
delete(s);
return true;
}二、队列Queue
基本概念
- 只允许在表的一端(队尾)插入，表的另一端(队头)进行删除操作的受限的线性表。
- 先进先出FIFO
- 队列的基本操作
队列的基本操作
- InitQueue(&Q): 初始化队列，构造一个空队列Q.
- QueueEmpty(Q):判队列空，若队列Q为空返回true，否则返回false.
- EnQueue(&Qx):入队，若队列Q未满，则将x加入使之成为新的队尾.
- DeQueue(&Q&x):出队，若队列Q非空，则删除队头元素，并用x返回.
- GetHead(Q&x):读队头元素，若队列Q非空则用x返回队头元素
- ClearQueue(&Q):销毁队列，并释放队列Q占用的内存空间。
存储结构
- 队头指针：指向队头元素
- 队尾指针：指向队尾元素的下一个位置
- 队列存储的基本操作
//队列的顺序存储类型
# define MaxSize 10; //定义队列中元素的最大个数
typedef struct{
ElemType data[MaxSize]; //用静态数组存放队列元素
//连续的存储空间，大小为——MaxSize*sizeof(ElemType)
int front, rear; //队头指针和队尾指针
}SqQueue;
//初始化队列
void InitQueue(SqQueue &Q){
//初始化时，队头、队尾指针指向0
Q.rear = Q.front = 0;
}
void test{
SqQueue Q; //声明一个队列
InitQueue(Q);
//...
}
// 判空
bool QueueEmpty(SqQueue 0){
if(Q.rear == Q.front) //判空条件后
return true;
else
return false;
}2. 循环队列
定义：将循环队列臆造为一个环状的空间，即把存储队列元素的表从逻辑上视为一个环，称为循环队列。
基本操作
a%b == a除以b的余数
初始：Q.front = Q.rear = 0;
队首指针进1：Q.front = (Q.front + 1) % MaxSize
队尾指针进1：Q.rear = (Q.rear + 1) % MaxSize —— 队尾指针后移，当移到最后一个后，下次移动会到第一个位置
队列长度：(Q.rear + MaxSize - Q.front) % MaxSize
三、栈的应用
栈在括号匹配中的应用
用栈实现括号匹配
- ((())) 最后出现的左括号最先被匹配 (栈的特性—LIFO);
- 遇到左括号就入栈;
- 遇到右括号，就“消耗”一个左括号 (出栈);
匹配失败情况：
- 扫描到右括号且栈空，则该右括号单身;
- 扫描完所有括号后，栈非空，则该左括号单身;
- 左右括号不匹配;
#define MaxSize 10
typedef struct{
char data[MaxSize];
int top;
} SqStack;
//初始化栈
InitStack(SqStack &S)
//判断栈是否为空
bool StackEmpty(SqStack &S)
//新元素入栈
bool Push(SqStack &S, char x)
//栈顶元素出栈，用x返回
bool Pop(SqStack &S, char &x)
bool bracketCheck(char str[], int length){
SqStack S; //声明
InitStack(S); //初始化栈
for(int i=0; i<length; i++){
if(str[i] == '(' || str[i] == '[' || str[i] == '{'){
Push(S, str[i]); //扫描到左括号，入栈
}else{
if(StackEmpty(S)) //扫描到右括号，且当前栈空
return false; //匹配失败
char topElem; //存储栈顶元素
Pop(S, topElem); //栈顶元素出栈
if(str[i] == ')' && topElem != '(' )
return false;
if(str[i] == ']' && topElem != '[' )
return false;
if(str[i] == '}' && topElem != '{' )
return false;
}
}
StackEmpty(S); //栈空说明匹配成功
}
栈在表达式求值中的应用
- 前缀表达式 (波兰表达式)：运算符在两个操作数前面
- 后缀表达式 (逆波兰表达式)：运算符在两个操作数后面
- 中缀表达式 (需要界限符)：运算符在两个操作数中间
中缀表达式转后缀表达式-手算
- 步骤1： 确定中缀表达式中各个运算符的运算顺序
- 步骤2： 选择下一个运算符，按照[左操作数 右操作数 运算符]的方式组合成一个新的操作数
- 步骤3： 如果还有运算符没被处理，继续步骤2
“左优先”原则: 只要左边的运算符能先计算，就优先算左边的 (保证运算顺序唯一)；
中缀：A + B - C * D / E + F
① ④ ② ③ ⑤
后缀：A B + C D * E / - F +
中缀表达式转后缀表达式-机算
初始化一个栈，用于保存暂时还不能确定运算顺序的运算符。从左到右处理各个元素，直到末尾。可能遇到三种情况:
- 遇到操作数: 直接加入后缀表达式。
- 遇到界限符: 遇到 ‘(’ 直接入栈; 遇到 ‘)’ 则依次弹出栈内运算符并加入后缀表达式，直到弹出 ‘(’ 为止。注意: '(' 不加入后缀表达式。
- 遇到运算符: 依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到 ‘(’ 或栈空则停止。之后再把当前运算符入栈。
按上述方法处理完所有字符后，将栈中剩余运算符依次弹出，并加入后缀表达式。
后缀表达式的计算—手算:
从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应的运算，合体为一个操作数
后缀表达式的计算—机算
用栈实现后缀表达式的计算（栈用来存放当前暂时不能确定运算次序的操作数）
- 步骤1: 从左往后扫描下一个元素，直到处理完所有元素;
- 步骤2: 若扫描到操作数，则压入栈，并回到步骤1;否则执行步骤3;
- 步骤3: 若扫描到运算符，则弹出两个栈顶元素，执行相应的运算，运算结果压回栈顶，回到步骤1;
栈在递归中的应用
函数调用的特点：最后被调用的函数最先执行结束(LIFO)
函数调用时，需要用一个栈存储：
- 调用返回地址
- 实参
- 局部变量
递归调用时，函数调用栈称为 “递归工作栈”:
- 每进入一层递归，就将递归调用所需信息压入栈顶；
- 每退出一层递归，就从栈顶弹出相应信息；
缺点：太多层递归可能回导致栈溢出；
适合用“递归”算法解决：可以把原始问题转换为属性相同，但规模较小的问题
