「数据结构」栈和队列

栈

栈的基本概念

定义
1. 栈是只允许在一端进行插入或删除操作的线性表
2. 栈顶：线性表允许进行插入删除的那一端
3. 栈底：固定的，不允许进行插入和删除的另一端
4. 空栈：不含任何元素
5. 特点：后进先出（LIFO）
基本操作
1. InitStack(&S)：初始化一个空栈S
2. StackEmpty(S)：判断一个栈是否为空，若栈S为空则返回true，否则返回false
3. Push(&S,x)：进栈，若栈S未满，则将x加入使之成为新栈顶
4. Pop(&S,%=&x)：出栈，若栈S非空，则用x返回栈顶元素
5. GetTop(S,&x)：读栈顶元素，若栈S非空，则用x返回栈顶元素
6. DestroyStack(&S)：销毁栈，并释放栈S占用的存储空间
卡特兰数：n个不同元素进栈，出栈元素的不同排列的个数为 $\frac{1}{n+1}C^n_{2n}$

栈的顺序存储结构

顺序栈的定义

#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;    //指针先加1S.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;       //栈顶指针减1return 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);//...
}

栈满条件：top==MaxSize
顺序栈的缺点：栈的大小不可变
共享栈
1. 定义：利用栈底位置相对不变的特性，可以让两个顺序栈共享一个一维数组空间，将两个栈的栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延伸

栈的链式存储结构

与链表类似，入栈和出栈的操作都在链表的表头进行

队列

队列的概念

定义：队列是只允许在一端进行插入（入队），在另一端删除（出队）的线性表
队头：允许删除的一端
队尾：允许插入的一端
空队列：不含任何元素的空表
队列的特点：先进先出（FIFO）
队列的基本操作
1. InitQueue(&Q): 初始化队列，构造一个空队列Q
2. DestroyQueue(&Q): 销毁队列，并释放队列Q所占用的内存空间
3. EnQueue(&Q, x): 入队，若队列Q未满，将x加入，使之成为新的队尾
4. DeQueue(&Q, &x): 出队，若队列Q非空，删除队头元素，并用x返回
5. GetHead(Q,&x): 读队头元素，若队列Q非空，则将队头元素赋值给x
6. QueueEmpty(Q): 判队列空，若队列Q为空，则返回true，否则返回false

队列的顺序存储结构

队列的顺序实现

# define MaxSize 10;     //定义队列中元素的最大个数
typedef struct{ElemType data[MaxSize];   //用静态数组存放队列元素int front, rear;          //队头指针和队尾指针
}SqQueue;

初始化操作

//初始化队列
void InitQueue(SqQueue &Q){//初始化时，队头、队尾指针指向0Q.rear = Q.front = 0;
}// 判断队列是否为空
bool QueueEmpty(SqQueue 0){if(Q.rear == Q.front)    //队空条件return true;else return false;
}

入队操作

bool EnQueue(SqQueue &Q, ElemType x){if((Q.rear+1)%MaxSize == Q.front)    //队满return false;    //队满报错Q.data[Q.rear] = x;    //将x插入队尾Q.rear = (Q.rear + 1) % MaxSize;    //队尾指针加1取模return true;
}

出队操作

//出队，删除一个队头元素，用x返回
bool DeQueue(SqQueue &Q, ElemType &x){if(Q.rear == Q.front)              //队空报错return false;  x = Q.data[Q.front];Q.front = (Q.front + 1) % MaxSize; //队头指针后移动return true;
}

获得队头元素

bool GetHead(SqQueue &Q, ElemType &x){if(Q.rear == Q.front)              //队空报错return false;  x = Q.data[Q.front];return true;
}

判断队列已满/已空

方案一：牺牲一个存储单元（实现代码同1）
1. 初始化时：rear=front=0;
2. 队空条件：Q.rear==Q.front;
3. 队满条件：(Q.rear+1)%MaxSize == Q.front
4. 队列元素个数：(rear+MaxSize-front)%MaxSize;

方案二

实现

#define MaxSize 10;     //定义队列中元素的最大个数
typedef struct{ElemType data[MaxSize];   //用静态数组存放队列元素int front, rear;          //队头指针和队尾指针int size;
}SqQueue;

初始化时

rear=front=0;
size=0;

插入成功：size++;
删除成功：size--;
队满条件：size==Maxsize;
队空条件：size==0;

方案三

实现

#define MaxSize 10;     //定义队列中元素的最大个数
typedef struct{ElemType data[MaxSize];   //用静态数组存放队列元素int front, rear;          //队头指针和队尾指针int tag;    //最近进行的是删除/插入
}SqQueue;

初始化时

rear=front=0;
tag=0;

插入成功：tag=1;
删除成功：tag=0;
队满条件：rear==front&&tag==1;
队空条件：rear==front&&tag==0;

队列的链式存储结构

定义队列

typedef struct LinkNode{      //链式队列结点ElemType data;struct LinkNode *next;
}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)     //也可用 Q.front -> next == NULLreturn true;elsereturn false;
}

不带头结点

void InitQueue(LinkQueue &Q){//初始化时，front、rear都指向NULLQ.front = NULL;Q.rear = NULL;
}//判断队列是否为空
bool IsEmpty(LinkQueue Q){if(Q.front == NULL)return true;elsereturn false;
}

入队

带头结点

//新元素入队 (表尾进行)
void EnQueue(LinkQueue &Q, ElemType x){LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode)); //申请一个新结点s->data = x;s->next = NULL;     //s作为最后一个结点，指针域指向NULLQ.rear->next = s;   //新结点插入到当前的rear之后Q.rear = s;         //表尾指针指向新的表尾
}

不带头结点

//新元素入队
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 == Q.rear)return false;                    //空队LinkNode *p = Q.front->next;    //p指针指向即将删除的结点x = p->data;Q.front->next = p->next;             //修改头结点的next指针if(Q.rear == p)                      //此次是最后一个结点出队Q.rear = Q.front;                //修改rear指针free(p);                             //释放结点空间return true;
}

不带头结点

//队头元素出队
bool DeQueue(LinkQueue &Q, ElemType &x){if(Q.front == Q.rear)return false;                    //空队LinkNode *p = Q.front;    //p指针指向即将删除的结点x = p->data;Q.front = p->next;             //修改头结点的next指针if(Q.rear == p){    //此次是最后一个结点出队Q.rear==NULL:Q.front==NULL;}                      free(p);     //释放结点空间return true;
}

双端队列

定义：只允许从两端插入、两端删除的线性表
1. 输入受限的双端队列：允许一端插入，两端删除的线性表
2. 输出受限的双端队列：允许两端插入，一端删除的线性表

栈和队列的应用

栈在括号匹配中的应用

#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. a + b
2. a + b - c
3. a + b - c*d

后缀表达式 (逆波兰表达式)

规则：运算符在两个操作数后面
例
1. a b +
2. ab+ c - / a bc- +
3. ab+ cd* -
中缀表达式转后缀表达式
1. 确定中缀表达式中各个运算符的运算顺序
2. 选择下一个运算符，按照[左操作数右操作数运算符]的方式组合成一个新的操作数
3. 如果还有运算符没被处理，继续步骤2

“左优先”原则: 只要左边的运算符能先计算，就优先算左边的 (保证运算顺序唯一)

用栈实现中缀表达式转后缀表达式
1. 初始化一个栈，用于保存暂时还不能确定运算顺序的运算符。从左到右处理各个元素，直到末尾。可能遇到三种情况
  1. 遇到操作数: 直接加入后缀表达式
  2. 遇到界限符: 遇到 ‘(’ 直接入栈; 遇到 ‘)’ 则依次弹出栈内运算符并加入后缀表达式，直到弹出 ‘(’ 为止。注意: ‘(’ 不加入后缀表达式
  3. 遇到运算符: 依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到 ‘(’ 或栈空则停止。之后再把当前运算符入栈
2. 按上述方法处理完所有字符后，将栈中剩余运算符依次弹出，并加入后缀表达式
后缀表达式的计算：从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应的运算，合体为一个操作数
用栈实现后缀表达式的计算（栈用来存放当前暂时不能确定运算次序的操作数）
1. 从左往后扫描下一个元素，直到处理完所有元素
2. 若扫描到操作数，则压入栈，并回到步骤1;否则执行步骤3
3. 若扫描到运算符，则弹出两个栈顶元素，执行相应的运算，运算结果压回栈顶，回到步骤1

先出栈的是“右操作数”

前缀表达式 (波兰表达式)

规则：运算符在两个操作数前面
例
1. - a b
2. +ab c
3. - +ab *cd
中缀表达式转前缀表达式
1. 确定中缀表达式中各个运算符的运算顺序
2. 选择下一个运算符，按照[运算符左操作数右操作数]的方式组合成一个新的操作数
3. 如果还有运算符没被处理，就继续执行步骤2

“右优先”原则: 只要右边的运算符能先计算，就优先算右边的;

用栈实现前缀表达式的计算
1. 从右往左扫描下一个元素，直到处理完所有元素
2. 若扫描到操作数则压入栈，并回到步骤1，否则执行步骤3
3. 若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到步骤1；

先出栈的是“左操作数”

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

栈在递归中的应用

函数调用的特点：最后被调用的函数最先执行结束(LIFO)
函数调用时，需要用一个栈存储
1. 调用返回地址
2. 实参
3. 局部变量
递归调用时，函数调用栈称为 “递归工作栈”
1. 每进入一层递归，就将递归调用所需信息压入栈顶
2. 每退出一层递归，就从栈顶弹出相应信息
3. 缺点： 太多层递归可能回导致栈溢出

数组和特殊矩阵

数组的定义

数组是由n(n>=1)个相同类型的数据元素构成的有限序列，每个数据元素称为一个数组元素，每个元素在n个线性关系中的序号称为该元素的下标，下标的取值范围称为数组的维界

数组的存储结构

一维数组
1. 各数组元素大小相同，物理上连续存放
2. 数组下标：默认从0开始
3. 数组元素 a[i] 的存放地址 = $L OC + i * s i zeo f (El e m T y p e)$
  1. LOC为数组起始地址
二维数组
1. 行优先/列优先存储优点：实现随机存储
2. M行N列的二维数组 b[M][N] 中，b[i][j]的存储地址：
  1. 行优先存储: $L OC + (i \times N + j) \times s i zeo f (El e m T y p e)$
  2. 列优先存储： $L OC + (j \times M + i) \times s i zeo f (El e m T y p e)$
普通矩阵的存储：使用二维数组存储

描述矩阵元素时，行、列号通常从1开始
描述数组时，通常下标从 0 开始

特殊矩阵的压缩存储

矩阵的压缩存储：为多个相同的非零元素只分配一个存储空间；对零元素不分配空间。

对称矩阵
1. 若n 阶方阵中任意一个元素 $a_{i,j}$ 都有 $a_{i,j}=a_{j,i}$ 则该矩阵为对称矩阵
2. 策略：只存储主对角线+下三角区；按行优先原则将各元素存入一维数组中
3. 数组大小： $\frac{n(n+1)}{2}$
4. 元素下标对应关系：k为 $a_{i,j}$ 在一维数组中的下标

$\left\{ \begin{array}{l} \frac{i(i-1)}{2}+j-1, \quad i \ge j \quad (下三角区和主对角线元素) \\ \frac{j(j-1)}{2}+i-1, \quad i<j \quad (上三角区元素a_{i,j}=a_{j,i}) \ \end{array} \right.$

三角矩阵
1. 以主对角线划分，三角矩阵有上（下）三角两种。上（下）三角矩阵的下（上）三角（不含主对角线）中的元素均为常数。在大多数情况下，三角矩阵常数为零
2. 策略：按行优先原则将元素存入一维数组中（同对称矩阵）。并在最后一个位置存储常量
3. 元素下标对应关系：k为 $a_{i,j}$ 在一维数组中的下标

$\left\{ \begin{array}{l} \frac{i(i-1)}{2}+j-1, \quad i \ge j \quad (下三角区和主对角线元素) \\ \frac{n(n+1)}{2}, \quad i<j \quad (上三角区元素a_{i,j}=a_{j,i}) \ \end{array} \right.$
3. 三对角矩阵（带状矩阵）
1. 当 $∣ i - j ∣ > 1$ 时，有 $a_{i,j}=0 (1 \leq i,j \leq n)$
2. 策略：按行优先(或列优先) 原则，只存储带状部分
3. 元素下标对应关系：k为 $a_{i,j}$ 在一维数组中的下标 k=2i+j-3