（3）数据结构--栈与队列-CSDN博客

创销

InitStack(&S)：初始化栈。构造一个空栈 S，分配内存空间。
DestroyStack(&S)：销毁栈。销毁并释放栈 S 所占用的内存空间。

增删
Push(&S,x)：进栈，若栈S未满，则将x加入使之成为新栈顶。
Pop(&S,&x)：出栈，若栈S非空，则弹出栈顶元素，并用x返回。

查（只是读栈顶元素，Pop是删除栈顶元素）
GetTop(S, &x)：读栈顶元素。若栈 S 非空，则用 x 返回栈顶元素
其他常用操作：
StackEmpty(S)：判断一个栈 S 是否为空。若S为空，则返回true，否则返回false。

1.3.顺序栈

1.3.1.顺序栈的定义

// 顺序栈，与顺序表类似
#define MaxSize 10;         //定义栈中元素最大个数
typedef struct{            
    ElemType data[MaSize];    //静态数组存放栈中元素
    int top;                  //栈顶置针。
}SqStack;

void testStack(){
    SqStack L; //声明一个顺序栈（分配空间）
}

//这里使用声明的方式分配内存空间，并没有使用malloc函数。
//会在会在销毁函数（top=-1）结束之后又系统自动回收。

1.3.2.顺序栈的初始化

#define MaxSize 10;        //定义栈中元素最大个数
typedef struct{            
    ElemType data[MaxSize];    //用静态数组存放栈中元素
    int top;                    //栈顶置针
}SqStack;

//初始化顺序栈
bool InitStack(SqStack &S){
    S.top=-1;            //初始化栈顶置针
    return true;
}

void testSqStack(){
    SqStack S;        //声明一个顺序栈（分配空间）
    InitStack(S);
}

//判断栈是否为空栈
bool StackEmpty(SqStack S){
    if(S.top==-1)
        return true;
    else
        return false;
}

1.3.3.进栈

top 初始是-1，所以要先加1，然后再进栈

思考：如果top初始为0呢，在 1.3.6栈的另一种表达方式实现

#define MaxSize 10;   //栈中元素最大个数
typedef struct{
    ElemType data[MaxSize];    //静态数组存放到栈中
    int top;                //栈顶置针
}SqStack;

//新元素入栈
bool push(SqStack S,ElemType x){
    if(S.top==MaxSize-1)  //栈满返回false
        return false;
    S.top=S.top+1;  //先加1
    S.data[S.top]=x;  //再入栈
    return false;
}


注：
S.top=S.top+1;
S.data[S.top]=x; 
等价于
S.data[++S.top]=x;

1.3.4.出栈

top 初始是-1的，top是直接指向栈顶元素的，所以先出栈，然后top-1

思考：如果top初始为0呢，在 1.3.6栈的另一种表达方式实现

#define MaxSize 10;        //栈中元素最大个数
typedef struct{
    ElemType data[MaxSize];    //静态数组存放栈中元素
    int top;                    //栈顶指针
}SqStack;

//出栈操作
bool Pop(SqStack &S,Elemtype &x){
    if(S.top==-1)        //栈为空返回false
        return false;
    x=S.data[S.top];  //先出栈
    S.top=S.top-1;    //再减1
}

注：
x=S.data[S.top];
S.top=S.top-1;
等价于
x=S.data[S.top--];

1.3.5.读栈顶元素

bool GetTop(SqStack S,ElemType &x){
    if(S.top==-1)  //栈空报错
        return false;
    x=S.data[S.top];    //x记录栈顶元素
    return true;
}

1.3.6.栈的另一种表达方式

栈顶初始化为0。

当栈满了，top=MaxSize

重点思考：top指向栈头元素的上一个。

Push：是先入栈，top再加1；

Pop：top先减1，再出栈。

#define MaxSize 10;
typedef struct{
    ElemType data[MaxSize];
    int top;
}SqStack;

//初始化栈
bool InitStack(SqStack &S){
    S.top=0; //指向0
}

void testStack(){    判断栈空
    SqStacks;//声明一个顺序栈
    InitStack(S);
}

//判断栈为空
bool StackEmpty(SqStack S){
    if(S.top==0)
        return true;
    else
        return false;
}

//入栈操作
bool Push(SqStack &S,ElemType x){
    if(S.top == MaxSize)    //栈满，报错
        return false;
    S.data[S.top++]=x;  //先入栈，后加1
    return true;
}
 
//出栈操作
bool Pop(Sqstack &S,ElemType &x){
    if(S.top==0)    //栈空，报错
        return false;
    x=S.data[--S.top]; //先减1，后出栈
    return true;
}

1.3.7.共享栈

两个栈共享同一片空间就是共享栈

其中判别栈满条件是top0+1=top1

// 共享栈
#define MaxSize 10;    
typedef struct{
    ElemType data[MaxSize];
    int top0;    //0号栈顶指针
    int top1;    //1号栈顶指针
}SqStack;

bool InitStack(SqStack &s){
    s.top0=-1;          //初始化栈指针
    s.top0=MaxSize;  
    return true;
}

1.4.链栈的实现

链栈，其进栈操作其实对应于链表中对头结点的"后插"操作，出栈操作对应于链表中对头结点的"后删"操作,就是将链头的一端看作栈顶的一端。

//链栈的定义和链表的定义是相同的，只是命名不同
typedef struct Linknode{
    ElemType data;
    struct Linknode *next;
}LiStack;    //栈类型定义

//带头结点
bool InitStack(LiStack &L){
    L=(Linknode *)malloc(sizeof(Linknode));
    if(L==NULL)
        return false;    //内存不足，分配失败
    L->next=NULL;
    return true;    
}
 //判断时候为空栈
bool Empty(LinkList L){
    return(L->next == NULL);

注：链栈基本操作同链表

//带头结点，S栈中插入数据
bool Push(LiStack &S, int x){
    Linknode *s=(Linknode *)malloc(sizeof(Linknode)); //要入栈的节点
    if (s == NULL) {
        return false; // 内存分配失败
    }
    s->data=x;
    s->next=S->next;
    S->next=s;
    return true;
}


//带头结点
bool Pop(LiStack &S, int &e) {
    if (L->next == NULL) { // 栈空
        return false;
    }
    Linknode *q = S->next;
    e = q->data;
    S->next = q->next;
    free(q);
    return true;
}

//不带头节点思考，参考链表

二.队列

2.1.队列的基本概念

队列（Queue）是只允许在一端进行插入，在另一端删除的线性表

重要术语：队头（删除的一端）、队尾（插入的一端）、空队列

队列的特点：先进先出
First In First Out（FIFO）

2.2.队列的基本操作

创销

InitQueue(&Q)：初始化队列，构造一个空队列Q。
DestroyQueue(&Q)：销毁队列。销毁并释放队列Q所占用的内存空间。

增删
EnQueue(&Q,x)：入队，若队列Q未满，将x加入，使之成为新的队尾。
DeQueue(&Q,&x)：出队，若队列Q非空，删除队头元素，并用x返回。

查
GetHead(Q,&x)：读队头元素，若队列Q非空，则将队头元素赋值给x。
其他常用操作：
QueueEmpty(Q)：判队列空，若队列Q为空返回true，否则返回false

2.3.队列的顺序实现

2.3.1 队列定义

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

void testQueue(){
    SqQueue Q;  //声明一个队列（顺序存储）
    // 其他操作
}

2.3.2 队列初始化

队头指针与队尾指针初始指向0

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

//初始化队列
InitQueue(SqQueue &Q){
    //队头和队尾指针指向0
    Q.frnot=Q.rear=0;
}

void testQueue(){
    SqQueue Q;    //声明一个队列
    InitQueue(Q);
    //其他操作
}

//判断空队列
bool EmptyQueue(SqQueue Q){
    if(Q.front==Q.rear)    //队空条件
        return true;
    else
        return false;
}

2.3.3 入队操作

队头指针与队尾指针初始指向0，数据是先入队，rear再（rear+1)%MaxSize

#define MaxSize 10;
typedef struct{
    ElemType data[MaxSize];
    int front,rear;
}SqQueue;


//入队
bool enQueue(SqQueue &Q,ElemType x){
    if((Q.rear+1)%MaxSize==Q.front)//判段队列满
        return false;
    Q.data[Q.rear]=x;    /新元素插入队尾
    Q.rear=(Q.rear+1)%MaxSize; //队尾指针加1取模
    return false;
}

循环队列队满条件是：队尾指针的再下一个位置是队头，即(Q.rear+1)%MaxSize==Q.front

为什么需要不能再插入一个元素，并且使rear和front指向同一个元素呢？

初始化队列，rear指针与front指针就是指向同一个位置，判断空队列也是rear指针与front指针指向同一个位置。如果再插入一个元素rear和front指针指向同一个位置，判满与判空混淆，必须牺牲一个存储单元

2.3.3 出队操作与获得队头元素

队头指针与队尾指针初始指向0，数据是先出队，front再（front+1)%MaxSize

//出队(删除一个队头元素，并用x返回)
bool DeQueue(SqQueue &Q,ElemType &x){
    if(Q.front==Q.rear)    //当队头指针与队尾指针再次指向同一个位置，队空
        return false;
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;    //队头指针后移
    return true;
}

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

2.3.4 判断队列已满/已空

方案一：

判断队列已满的条件：队尾指针的再下一个位置是队头

(Q.rear+1)%MaxSize==Q.front
队空条件：队头指针与队尾指针指向同一个地方

Q.rear=Q.front
队列元素个数：

(rear+MaxSize-front)%MaxSize

方案二：

#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];
    int front,rear;
    int size;    //用size表示当前队列的长度，当入队成功size++，出队成功size--
}SqQueue;

直接用size来判断是否是队空，队满

方案三：

#define Maxsize 10
typedef struct{
    ElemType data[Maxsize];
    int front,rear;
    int tag;    //记录最近进行的是删除/插入
//每次删除成功，都令tag=0，每次插入成功时，都令tag=1;
} SqQueue;

只有删除操作，才能导致队空，只有插入操作，才能导致队满

在考试时，也可能出现rear指向队尾元素的情况，如下图所示：

rear先往后移动，在入队

判满也不能用与判空相同的条件，如下图：

可以牺牲一个存储空间，即队空时，队尾指针在队头指针后面一个位置，队满时，队尾指针在队头指针后面两个位置。

//代码如下
//初始化队列
void InitQueue(SqQueue &Q) {
    Q.front = 0;
    Q.rear =MaxSze-1;
    
}
 
//判空
bool QueueEmpty(SqQueue Q){
    if((Q.rear+1)%MaxSize==Q.front)    //队空条件
        return true;
    else
        return false;
 
 
//判满
bool QueueFull(SqQueue Q){
    if((Q.rear+2)%MaxSize==Q.front)    //队满条件
        return true;
    else
        return false;

2.4.队列的链式实现

2.4.1 队列定义

typedef struct LinkNode{  //链式队列结点
    ElemType data;
    strcut LinkNode *next;
}LinkNode;

typedef struct{        //链式队列
    LinkNode *front,*rear;    //队列的对头和队尾指针
}LinkQueue;

链队列--链式存储实现的队列

2.4.2 队列初始化

带头结点

typedef struct LinkNode{
    ElemType data;
    struct LinkList *next;
}LinkNode;

typedef struct{
    struct LinkNode *front,*rear;
}LinkQueue;

//初始化（带头结点）
bool InitQueue(LinkQueue &Q){
    //初始化时，front，rear都指向头结点
    Q.front=Q.rear=(LinkNode *)malloc(sizeof(LinkNode));
    Q.front->next=NULL;
    return true;
}

//判断队列为空
bool IsEmpty(LinkQueue Q){
    if(Q.front==Q.rear)
        return true;
    else
        return false;
}

void testLinkQueue(){
    LinkQueue Q;    //声明一个队列
    InitQueue(Q);    //初始化队列
    //后续操作
}

不带头结点

//初始化操作（不带头结点）
bool InitQueue(LinkQueue &Q){
    Q.front=NULL;
    Q.rear=NULL;
    return true;
}

//判断队列是否为空（不带头节点）
bool IsEmpty(LinkQueue Q){
    if(Q.front==NULL)
        return true;
    else
        return false;
}

2.4.3 入队

带头结点

//新元素入队（带头结点）
void EnQueue(LinkQueue &Q ElemType x){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.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.rear==NULL){    //在空队列中插入第一个元素
        Q.front=s;       //修改怼头队尾指针
        Q.rear=s;
    }else{
        Q.rear->next=s;    //新结点插入到rear结点后边
        Q.rear=s;        //修改rear指针，指向队尾
    }
}

2.4.4 出队

带头结点

//队头元素出栈
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;        //修改rear指针，改成rear=front，表示空队
    free(p);                    //释放资源
    return true;
}

不带头结点

//队头元素出队（不带头结点）
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front==NULL)    //空队
        return false;
    LinkNode *p=Q.front;    //p指向出队结点，队头
    x=p->data;            //用变量x返回队头元素
    Q.front=p->next;        //修改front指针
    if(Q.rear==p){        //如果出队的是最后一个结点
        Q.front=NULL;        //front，rear指向NULL
        Q.rear==NULL;
    }
    free(p);        //释放资源
    return true;
}

对于顺序存储的队列，存储空间都是预分配的，预分配的存储空间耗尽，则队满。而对链式存储而言，一般不会对满，除非内存不足。

2.5.双端队列

栈：只允许从一端插入和删除的线性表

队列：只允许从一端插入、另一端删除的线性表

双端队列：只允许从两端插入、两端删除的线性表

双端队列还可以分为：

输入受限的双端队列：只允许从一端插入、两端删除的线性表

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

对于栈而言，若数据元素输入序列为 1,2,3,4，合法的出栈序列，可用卡特兰数计算：

三.栈的应用

3.1.括号匹配

在代码中出现的括号必须是成对的，这就是括号匹配的问题。最后出现的左括号最先被匹配（LIFO），如图所示

遇到左括号就入栈遇到右括号，就 “消耗”一个左括号。

所有括号都能两两配对。

当前扫描到的右括号与栈顶左括号不匹配

算法流程图：

#define MaxSize 10;
typedef struct{
    char data[MaxSize];
    int top;
}SqStack;

//初始化栈
void InitStack(SqStack &S){
    S.top=-1;
    return false;
}

//判断栈为空
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.data[++S.top]=x;    //top先加1，元素再入栈
    return true;
}

//出栈操作
bool Pop(SqStack &s,char &x){
    if(S.top==-1)
        return false;
    x=S.data[S.top--]; //先出栈top再减1
    return true;
}

//括号匹配
bool bracketCheck(char str[],int length){
    SqStack S;
    InitStack(S); //初始化一个栈
    //循环遍历str数组
    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;  //如果右括号为） 栈顶元素不为（返回false
            if(str[i]==']' && topElem!='[')
                return false;
            if(str[i]=='}' && topElem!='{')
                return false;
        }
    }
    return StackEmpty(S); //检索完全部括号后，栈空说明匹配成功
}

匹配失败情况：
①左括号单身②右括号单身③左右括号不匹配

3.2.表达式求值

3.2.1.三种算数表达式

中缀表达式

运算符在两个操作数的中间

后缀表达式（逆波兰表达式，Reverse Polish notation）

运算符在两个操作数后面

前缀表达式（波兰表达式，Polish notation）

运算符在两个操作数前面

3.2.2 中缀表达式转后缀表达式

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

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

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

扫描到操作数则压入栈中：

扫描到运算符则，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶：

后出栈的是左操作数.以此类推：

遇到“-”号，将两个栈顶元素取出，执行减法运算，再压回栈中。

最后得到中缀表达式：若表达式合法，则最后栈中只会留下一个元素，就是最终结果。

3.2.3 中缀表达式转前缀表达式

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

“右优先”原则：只要右边的运算符能先计算，就优先算右边的。可保证运算顺序唯一

用栈实现前缀表达式的计算：（与后缀表达式相反）
①从右往左扫描下一个元素，直到处理完所有元素
②若扫描到操作数则压入栈，并回到①；否则执行③
③若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到①

3.2.4计算机实现中缀表达式转后缀表达式

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

遇到操作数，直接加入后缀表达式。遇到运算符，由于栈空，直接将运算符入栈

遇到运算符（“-”）时，需要依次弹出栈中优先级高于或等于当前运算符的所有运算符。由于“+”号和"-"号优先级相同，所以把“+”号弹出，并且把“-”号放入栈中。

继续扫描到“*”号运算符，由于当前栈中的运算符是“-”号，比“*”号优先级低，所以不弹出栈。

所以“*”入栈，操作数D直接放到后缀表达式中。

接下来遇到“/”，由于“*”号和“/”运算优先级相等，所以* 出栈，

以此类推

带有括号的与上面一样。

3.2.5用栈实现中缀表达式的计算

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

操作数栈对应后缀表达式求值

运算符栈对应中缀转后缀

具体过程演示：

操作数放到操作数栈中，由于运算符栈空，所以“+”号可以直接入栈。

扫描到“-”号时，按照“中缀转后缀”的逻辑，由于运算符栈顶的“+”号和当前运算符“-”号优先级相同，所以弹出“+”号，并弹出操作数栈中的两个操作数，先出栈的为右操作数。

并且把当前运算符“-”号压入栈中。

按照规则继续操作，当遇到“/”号时，会把运算符栈的栈顶元素”*“弹出。

并弹出两个操作数，进行乘法运算，并压回操作数栈的栈顶。

遇到“E”，直接压入操作数栈。

遇到"+"号，需要将”/“和“-”号依次弹出。

弹出“/”号，并将两个操作数出栈进行运算，最后压回栈顶。

最后让“F”入栈，并将运算符栈的运算符"+"号弹出，让操作数栈的两个栈顶操作数进行加法运算。

3.3 递归

其算法的内部逻辑如下图所示，每进入一层递归，就将递归调用所需信息压入栈顶。计算阶乘

#include<stdio.h> 
//计算正整数n! 
int factorial(int n){
	if(n==0 || n==1)
		return 1;
	else
		return n*factorial(n-1);
}
 
int main(){
	int a;
	printf("请输入要求的阶乘:");
	scanf("%d",&a);
	int b=factorial(a);
	printf("%d",b);
}

其算法的内部逻辑如下图所示，每进入一层递归，就将递归调用所需信息压入栈顶。

每退出一层递归，就从栈顶弹出相应信息，当n=1时，return 1，并从栈顶弹出相应信息。第9层的n=2，所以return n*factorial(1)，即2*1，以此类推，到第1层时，返回的则是10*9！(9的阶乘)，即10的阶乘。

注意：若有太多的递归层，就有可能导致栈溢出，因为内存有限，系统开辟的函数调用栈也是有上限的。所以这也可以解释，为什么递归次数越多时间复杂度越高。

再例如递归算法实现斐波那契数列

#include<stdio.h> 
int Fib(int n){
    if(n==0)
        return 0;
    else if(n==1)
        return 1;
    else
        return Fib(n-1)+Fib(n-2);    
}
 
int main(){
    int a;
    printf("请输入要求第几个斐波那契数:");
    scanf("%d",&a);
    int b=Fib(a-1);
    printf("%d",b);
}

四.队列的应用

树的层次遍历

新建一个队列，从根结点出发，按层次遍历各个结点，具体操作如下：

1.扫描根结点（1号结点），并将其左右孩子放到队列的队尾，接着1号结点出队。

队列情况：②--->③

2.检查队头结点，将其左右孩子放到队列的队尾。

队列情况：② ---> ③ ---> ④ ---> ⑤

处理完2号结点，2号结点出队。

队列情况：③ ---> ④ ---> ⑤

3.以此类推，直到队列为空，完成树的层次遍历。

图的广度优先遍历

从1号结点出发：

1.遍历1号结点时，检查与1号结点相邻的结点有没有被遍历过，2号和3号结点都没有被遍历过，所以把它们放到队尾。

队列情况：① ---> ② ---> ③

处理完 ① 号结点后，①号结点出队。

队列情况：② ---> ③

2. 与 ② 号结点相邻的只有4号结点没被处理过，所以4号结点入队，2号结点出队。

队列情况：③ ---> ④

3.以此类推，直到队列为空，就完成了图的广度优先遍历。