第三章：栈和队列

3.1栈

3.1.1栈的概念和基本操作

栈（Stack）是只允许在一端 进行插入或删除操作的线性表 。
栈顶（Top），线性表允许进行插入删除的那一端。
栈底（Bottom），固定的，不允许进行插入删除的另一端。
空栈，不含任何元素的空表。
操作特性： 后进先出（Last In First Out）！
栈的基本操作：

• InitStack(&S)：初始化一个空栈
• StackEmpty(S)：判断一个栈是否为空，若栈S为空则返回true，否则返回false
• Push(&S,x)：进栈，若栈S未满，则将x加入使之成为新栈顶
• Pop(&S,&x)；出栈，若栈S非空，则弹出栈顶元素，并用x返回
• GetTop(S,&x)：读栈顶元素，若栈S非空，则用x返回栈顶元素
• DestroyStack(&S)：销毁栈，并释放栈S占用的存储空间

3.1.2栈的顺序存储结构

#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;//指针先加一
	S.data[S.top]=x;//新元素入栈
	//上两句等价于S.data[++S.top]=x;
	return true;
}
//出栈
bool Pop(SqStack &S,ElemType &x){
	if(S.top==-1)
		return false;
	x=S.data[S.top];//栈顶元素先出栈
	S.top=S.top-1;//指针再减一
	//上两句等价于x=S.data[S.top--];
	return true;
}//逻辑上删除
//读取栈顶元素
bool GetTop(SqStack S,ElemType &x){
	if(S.top==-1)
		return false;
	x=S.data[S.top];//x返回栈顶元素
	return true;
}
/*
思考初始化时top=0后续代码怎么写
了解共享栈
*/

3.1.3栈的链式存储结构

栈的链式存储就是单链表，但所有操作都在表头进行，单链表尽量不带头结点

typedef struct Linknode{//栈的链式存储类型
	ElemType data;//数据域
	struct Linknode *next;//指针域
}*LiStack;//类型定义

//初始化
void InitStack(LiStack &S){
	S=NULL;//消除脏数据
}
//判空
bool StackEmpty(LiStack S){
	if(S==NULL)
		return true;
	else
		return false;
}
//进栈
bool Push(LiStack &S,Elemtype e){
	Linknode *t = (Linknode *)malloc(sizeof(Linknode));
	if(t==NULL)//结点申请失败
		return false;
	t->data=e;
	if(S=NULL){//空表直接插入
		t->next=NULL;
		S=t;
		return true;
	}
	t->next=S;//后插操作
	S=t;
	return true;
}
//出栈
bool Pop(LiStack &S,ElemType &e){
	if(S==NULL)//空表
		return false;
	Linknode *t = S;
	e = t->data;//e返回被删元素值
	S = t->next;//断开
	free(t);//释放资源
	return true;
}
//读取栈顶元素
bool GetTop(LiStack S,ElemType e){
	if(S==NULL)//空表
		return false;
	e=S->data;//栈顶元素
	return true;
}

3.2队列

3.2.1队列的概念和基本操作

队列（Queue）简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，在表的另一端进行删除。
队头：只允许删除的一端，又称队首
队尾：只允许插入的一端
空队列：不含任何元素的空表
队列的基本操作：

• InitQueue(&Q)：初始化队列，构造一个空队列
• QueueEmpty(Q)：判空，若队列Q为空则返回true，否则返回false
• EnQueue(&Q,x)：入队，若队列Q未满，将x加入，使之成为新的队尾
• DeQueue(&Q,&x)：出队，若队列Q非空，删除队头元素，并用x返回
• GetHead(Q,&x)：读取队头元素，若队列Q非空，将队头元素赋给x

3.2.2队列的顺序存储结构

#define MaxSize 10
typedef struct{
	ElemType data[MaxSize];//存放队列元素的数组
	int front,rear;//队头指针和队尾指针
}SqQueue

定义存储类型后，发现不能充分利用存储空间，当执行若干次入队出队操作后rear指向队尾，front指向队中某元素，此时对满了吗？所以队列需变为循环队列。通过取余运算使之循环：

初始时：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

而循环队列又存在一些问题，当初始化时，rear=front；队满时，rear=front。应对此状况有三种解决方案：

• 方案一：牺牲一个单元区分对空和队满
  队满条件：(Q.rear+1)%MaxSize==Q.front
  队空条件：Q.front==Q.rear
  队列中元素个数：(Q.rear-Q.front+MaxSize)%MaxSzie
• 方案二：增设表示个数的数据成员，入队size++；出队size–
  队满条件：Q.size==MaxSize
  对空条件：Q.size==0
• 方案三：增设表示操作的数据成员，入队tag=1；出队tag=-1
  队满条件：(Q.rear==Q.front)&&(tag==1)
  对空条件：(Q.rear==Q.front)&&(tag==-1)

以下为方案一相关操作：

//初始化
void InitQueue(SqQueue &Q){
	Q.rear=Q.front=0;
}

//判空
bool QueueEmpty(SqQueue Q){
	if(Q.rear==Q.front)
		return true;
	else
		return false;
}

//入队
bool EnQueue(SqQueue &Q,ElemType e){
	if((Q.rear+1)%MaxSize==Q.front)//队满
		return false;
	Q.data[Q.rear]=e;
	Q.rear=(Q.rear+1)%MaxSize;//队尾指针加1，保证循环
	return true;
}

//出队
bool DeQueue(SqQueue &Q,ElemType &e){
	if(Q.rear==Q.front)//队空
		return false;
	e=Q.data[Q.front];
	Q.front=(Q.front+1)%MaxSize;//指针后移，逻辑上删除
	return true;
}

//读取队头元素
bool GetHead(SqQueue Q,ElemType &e){
	if(Q.rear==Q.front)
		return false;
	e=Q.data[Q.front];
	return true;
}

3.2.3队列的链式存储结构

//队列的链式存储类型
typedef struct LinkNode{
	ElemType data;
	struct LinkNode *next;
}LinkNode;
typedef struct{
	LinkNode *front,*rear;
}LinkQueue;

//带头结点的链队列相关操作：
//初始化
void InitQueue(LinkQueue &Q){
	//初始时，front、rear都指向头结点
	Q.front=Q.rear=(LinkNode *)malloc(sizeof(LinkNode));
	Q.front->next=NULL;
}
//判空
bool IsEmpty(LinkQueue Q){
	if(Q.front==Q.rear)//队头队尾指向同一结点为空
		return true;
	else
		return false;
}
//入队
void EnQueue(LinkQueue &Q,ElemType x){
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;//赋值
	s->next=NULL;//后跟空
	Q.rear->next=s;//插入队尾
	Q.rear=s;//尾指针指向队尾
}
//出队
bool DeQueue(LinkQueue &Q,ElemType &x){
	if(Q.front==Q.rear)//空队列
		return false;
	LinkNode *p=Q.front->next;
	x=p->data;//用变量x返回元素值
	Q.front->next=p->next;//修改头结点next指针
	if(Q.rear==p)//最后结点出队
		Q.rear=Q.front;//置空
	free(p);//释放结点空间
	return true;
}


//不带头结点的链队列相关操作
//初始化
void InitQueue(LinkQueue &Q){
	//初始时，front、rear都指向NULL
	Q.front=NULL;
	Q.rear=NULL;
}
//判空
bool IsEmpty(LinkQueue Q){
	if(Q.front==NULL)//队头或队尾值为空
		return true;
	else
		return false;
}
//入队
void EnQueue(LinkQueue &Q,ElemType x){
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
	s->data=x;
	s->next=NULL;
	if(Q.front==NULL){//在空队列插入第一个元素
		Q.front=s;//修改队头队尾指针
		Q.rear=s;
	}else{
		Q.rear->next=s;//新结点插入到rear结点之后
		Q.rear=s;//修改rear指针
	}
}
//出队
bool DeQueue(LinkQueue &Q,ElemType &x){
	if(Q.front==NULL)//空队列
		return false;
	LinkNode *p=Q.front;//p指针指向此次出队的结点
	x=p->data;
	Q.front=p->next;//出队，修改指针
	if(Q.rear==p){//最后结点出队
		Q.front=NULL;//置空
		Q.rear=NULL;
	}
	free(p);
	return true;
}

3.2.4双端队列

双端队列： 是指允许两端都可以进行入队和出队操作的队列，逻辑结构仍是线性结构；
输出受限的双端队列： 允许在一端进行插入和删除，但在另一端只允许插入的双端队列；
输入受限的双端队列： 允许在一端进行插入和删除，但在另一端只允许删除的双端队列；
考点： 判断输出序列合法性

3.3栈和队列的应用

3.3.1栈在括号匹配中的应用

例：
{ ( ( ( ) ) ) [ ] ( ) } 匹配成功
{ ( ) ( ) ( ( ( ) ) ) ] } 匹配失败

算法思想：

1. 初始设置一个空栈，顺序读入括号
2. 若是右括号，则或者使置于栈顶的左括号得以消解，或者是不合法情况（匹配失败，退出程序）
3. 若是左括号，压入栈中；算法结束时，栈为空，否则括号序列不匹配

匹配失败情况：

• 左括号单身
• 右括号单身
• 左右括号不匹配

#define MaxSize 10 //顺序栈最大容量
typedef struct{
	char data[MaxSize];
	int top;//栈顶指针
}SqStack;
//初始化栈
void InitStack(Sqstack &S);
//判空
bool StackEmpty(SqStack S);
//入栈
bool Push(SqStack &S,char 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;
		}
	}
	return StackEmpty(S);//检索完全部括号后，栈空说明匹配成功
}

粘贴复制直接运行代码如下：

#include <stdio.h>
#include <stdlib.h>

#define MaxSize 10 //顺序栈最大容量
typedef struct{
	char 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,char x){
	if(S.top==MaxSize-1)
		return false;
	S.top=S.top+1;//指针先加一
	S.data[S.top]=x;//新元素入栈
	//上两句等价于S.data[++S.top]=x;
	return true;
}
//出栈
bool Pop(SqStack &S,char &x){
	if(S.top==-1)
		return false;
	x=S.data[S.top];//栈顶元素先出栈
	S.top=S.top-1;//指针再减一
	//上两句等价于x=S.data[S.top--];
	return true;
}//逻辑上删除

//括号匹配
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);//出栈
			printf("出栈%c\n",topElem);
			//左右括号不匹配：
			if(str[i]==')' && topElem!='(')
				return false;
			if(str[i]==']' && topElem!='[')
				return false;
			if(str[i]=='}' && topElem!='{')
				return false;
		}
	}
	return StackEmpty(S);//检索完全部括号后，栈空说明匹配成功
}

int main () {
	char str[4]={'{','(',')','}'};
	if(bracketCheck(str,4))
		printf("success\n");
	else
		printf("failture\n");
	return 0;
}

3.3.2栈在表达式求值中的应用

中缀、后缀、前缀表达式：

中缀表达式	后缀表达式	前缀表达式
运算符在两个操作数中间	运算符在两个操作数后面	运算符在两个操作数前面
a+b	ab+	+ab
a+b-c	ab+c-	-+abc
a+b -c*d	ab+cd*-	-+ab*cd

中缀表达式转后缀表达式：
①确定中缀表达式中各个运算符的运算顺序
②选择下一个运算符，按照（左操作符 右操作符 运算符）的方式组合成一个新的操作数
③如果还有运算符没被处理，就继续②

左优先原则：只要左边的运算符能先计算，就优先算左边的

A+B*(C-D)-E/F：中缀③②①⑤④
ABCD-*+EF/-：后缀①②③④⑤

后缀表达式的计算（手算）：
从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应运算，合体为一个操作数
注意两个操作数的左右顺序

后缀表达式的计算（机算）：
①从左到右扫描下一个元素，直到处理完所有元素
②若扫描到操作数则压入栈，并返回①；否则执行③
③若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到①
注意先出栈的是右操作数：AB+等价于A进栈B进栈扫描到+，B出栈为右操作数

中缀表达式转前缀表达式：
①确定中缀表达式中各个运算符的运算顺序
②选择下一个运算符，按照（运算符 左操作符 右操作符）的方式组合成一个新的操作数
③如果还有运算符没被处理，就继续②

右优先原则：只要右边的运算符能先计算，就优先算右边的

A+B*(C-D)-E/F：中缀③②①⑤④
+A-*B-CD/EF：前缀⑤④③②①

前缀表达式的计算（机算）：
①从右到左扫描下一个元素，直到处理完所有元素
②若扫描到操作数则压入栈，并返回①；否则执行③
③若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到①
注意先出栈的是左操作数：-AB等价于B进栈A进栈扫描到+，A出栈为左操作数

中缀表达式转后缀表达式（机算）：
初始化一个栈，用于保存暂时还不能确定运算顺序的运算符
从左到右处理各个元素，直到末尾。可能遇到三种情况：
①遇到操作数。直接加入后缀表达式
②遇到界限符。遇到 “(” 直接入栈；遇到 “)” 则依次弹出栈内运算符并加入后缀表达式，直到弹出 “(” 为止。注意：“(” 不加入后缀表达式。
③遇到运算符。依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到 “(” 或栈空则停止。之后再把当前运算符入栈。

中缀表达式的计算（用栈实现）：
初始化两个栈，操作数栈和运算符栈
若扫描到操作数，压入操作符栈
若扫描到运算符或界限符，则按照“中缀转后缀”相同的逻辑压入运算符栈（期间也会弹出运算符，每当弹出一个运算符时，就需要再弹出两个操作数栈的栈顶元素并执行相应运算，运算结果再压回操作数栈）

3.3.3栈在递归中的应用

递归的精髓在于能否将原始问题转换为属性相同但规模较小的问题

递归模型必须满足两个条件：

• 递归表达式（递归体）
• 边界条件（递归出口）

函数调用的特点：最后被调用的函数最先执行结束（LIFO）

函数调用时，需要用一个“函数调用栈”存储：
①调用返回地址
②实参
③局部变量

递归调用时，函数调用栈可称为"递归工作栈"
每进入一层递归，就将递归调用所需信息压入栈顶
每退出一层递归，就从栈顶弹出相应信息

缺点：效率低，太多层递归可能会导致栈溢出，可能包含很多重复计算
可以自定义栈将递归算法改造成非递归算法

3.3.3队列的应用

树的层次遍历：
①根结点入队
②若队空（所有结点都已处理完毕），则结束遍历；否则重复③操作
③队列的第一个结点出队，并访问之。若其有左孩子，则将左孩子入队；若其有右孩子，则将右孩子入队，返回②

图的广度优先遍历：
①第一个结点入队
②若队空（所有结点都已处理完毕），则结束遍历；否则重复③操作
③队列的第一个结点出队，并访问之。若其相邻的结点有位入队的，则依次入队，返回②

计算机系统的应用
先来先服务FCFS（First Come First Service）

3.4特殊矩阵压缩存储

3.4.1数组存储结构

一维数组：ElemType a[10]
起始地址LOC
各数组元素大小相同，且物理上连续存放
各数组元素a[i]的存放地址=LOC+i*sizeof(ElemType) (0<=i<10)
注：除非题目特别说明，否则数组下标默认从0开始

二维数组：ElemType b[2][4]
起始地址LOC
M行N列的二维数组b[M][N]中，若按 行优先 存储，则
b[i][j]的存储地址=LOC+(i*N+j)sizeof(ElemType)
M行N列的二维数组b[M][N]中，若按 列优先 存储，则
b[i][j]的存储地址=LOC+(jM+i)*sizeof(ElemType)

3.4.2矩阵存储

对称矩阵压缩存储：
策略：只存储主对角线和下三角区，按 行优先 原则将各元素存入一维数组中
一维数组元素个数=1+2+3+…+n=n(n+1)/2
一维数组元素下标：0…n(n+1)/2-1
矩阵：a_ij -> 一维数组B[k]
矩阵对称性质：a_ij = a_ji
k = i(i-1)/2+j-1 , i>=j (下三角区和主对角线元素)
k = j(j-1)/2+i-1 , i>=j (上三角区元素 a_ij = a_ji)

策略：只存储主对角线和下三角区，按 列优先 原则将各元素存入一维数组中
k=[n+(n+1)+…+(n-j+2)]+(i-j)+1

三角矩阵压缩存储：
策略：按 行优先 原则将主对角线和下三角区元素存入一维数组中，并在最后一个位置存储常量c
一维数组元素个数=1+2+3+…+n=n(n+1)/2+1
一维数组元素下标：0…n(n+1)/2
矩阵：a_ij -> 一维数组B[k]
矩阵对称性质：a_ij = a_ji
k = i(i-1)/2+j-1 , i>=j (下三角区和主对角线元素)
k=n(n+1)/2 (上三角区元素)

策略：按 行优先 原则将主对角线和上三角区元素存入一维数组中，并在最后一个位置存储常量c
一维数组元素个数=1+2+3+…+n=n(n+1)/2+1
一维数组元素下标：0…n(n+1)/2
矩阵：a_ij -> 一维数组B[k]
矩阵对称性质：a_ij = a_ji
k = (i-1)(2n-i+2)/2+(j-1) , i>=j (上三角区和主对角线元素)
k=n(n+1)/2 (下三角区元素)

三对角矩阵压缩存储：
三对角矩阵又称带状矩阵，当|i-j|>1时，有a_ij=0（i>=1,j<=n）
策略：按行优先或列有限原则，只存储带状部分
一维数组元素个数=3n-2
一维数组元素下标：0…3n-3
矩阵：a_ij -> 一维数组B[k]
前i-1行共3(i-1)-1个元素；a_ij是i行第j-i+2个元素；a_ij是第2i+j-2
k=2i+j-3

第k+1个元素，在第几行第几列？
前i-1行共3(i-1)-1个元素；前i行共3i-1个元素，显然：
3(i-1)-1<k+1<=3i-1
i>=(k+2)/3
i=|^-(k+2)/3^-|向上取整

稀疏矩阵压缩存储
稀疏矩阵：非零元素远远少于矩阵元素的个数
策略1：顺序存储–三元组<行，列，值>
矩阵：
0 0 4 0 0 5
0 3 0 9 0 0
0 0 0 0 7 0
0 2 0 0 0 0
0 0 0 0 0 0
三元组：

i（行）	j（列）	v（值）
1	3	4
1	6	5
2	2	3
2	4	9
3	5	7
4	2	2

策略2：十字链表