栈和队列的基本操作

栈

基本概念

栈是只允许在一端进行插入或删除操作的线性表

顺序栈的初始化

#include 

#define MaxSize 10
using namespace std;
typedef struct {
    int data[MaxSize];
    int top;
} SqStack;

void InitStack(SqStack &S){
    S.top=-1;
}

int main() {
    SqStack S;
}

进栈

bool Push(SqStack &S, int x) {
    if (S.top == MaxSize - 1)
        return false;
    S.top += 1;
    S.data[S.top] = x;
    return true;
}

出栈

bool Pop(SqStack &S,int &x){
    if (S.top==-1)
        return false;
    x=S.data[S.top];
    S.top--;
    return true;
}

读取栈顶元素

bool GetTop(SqStack S,int &x){
    if (S.top==-1)
        return false;
    x=S.data[S.top];
    return true;
}

栈的应用-括号匹配

#include 
#include 
#include 
#include 
#include 
#include 

#define MaxSize 10
using namespace std;
typedef struct {
    char data[MaxSize];
    int top;
} Sqstack;

void InitStack(Sqstack &S);

bool Empty(Sqstack S);

bool Push(Sqstack &S, char x);

bool Pop(Sqstack &S, char &x);

bool check(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 (Empty(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 Empty(S);
}

使用STL

#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;
stack<char> s;

bool check(string str) {
    for (int i = 0; i < str.size(); ++i) {
        if (str[i] == '(' || str[i] == '[' || str[i] == '{') {
            s.push(str[i]);
        } else{
            if (s.empty())
                return false;
            char topstr=s.top();
            s.pop();
            if (str[i]==')'&&topstr!='(')
                return false;
            if (str[i]==']'&&topstr!='[')
                return false;
            if (str[i]=='}'&&topstr!='{')
                return false;
        }
    }
    return s.empty();
}

int main() {
    string a;
    cin>>a;
    if (check(a))
        cout<<"Yes";
    else
        cout<<"No";
}

栈的应用-求表达式的值

用栈实现表达式的运算，输入时表达式是中缀的，利用栈可以将其转换为后缀表达式。

中缀表达式转后缀

1. 遇到操作数，直接加入后缀表达式
2. 遇到界限符，遇到’(‘直接入栈，遇到’)‘则依次弹出栈内运算符并加入后缀表达式，直到弹出’('为止
3. 遇到运算符，则依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到’('或栈空则停止。之后再把当前运算符入栈。

后缀表达式的计算：

1. 从左到右扫描下一个元素，直到处理完所有元素；
2. 若扫描到操作数则压入栈，并回到1，否则执行3；
3. 若扫描到运算符，则弹出栈顶两个元素，执行相应运算，运算结果压回栈顶，回到1。

需要注意的是，弹出两个元素时，先出栈的在操作符右边。

如果是通过前缀表达式求值，则与后缀表达式不同的是1中要从右往左扫描，且3中弹出两个元素时，先出栈的在操作符左边。

队列

基本概念

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

顺序队列的初始化

初始化队列并判断队列是否为空

#include 

#define MaxSize 10
using namespace std;

typedef struct {
    int data[MaxSize];
    int front, rear;
    int size;
} SqQueue;

void InitQueue(SqQueue &Q){
    Q.front=Q.rear=0;
}

bool Empty(SqQueue Q){
    if (Q.rear==Q.front)
        return true;
    else
        return false;
}

int main() {
    SqQueue Q;
    InitQueue(Q);

}

入队

元素从队列的尾部插入，队首删除，一般使用循环队列，判断队列已满的条件是(Q.rear+1)%MaxSize==Q.front

bool Push(SqQueue &Q, int x) {
    if ((Q.rear+1)%MaxSize==Q.front)
        return false;
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MaxSize;
    return true;
}

出队

bool Pop(SqQueue &Q, int &x) {
    if (Q.rear == Q.front)
        return false;
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    return true;
}

读取队首元素

bool Top(SqQueue &Q, int &x) {
    if (Q.rear == Q.front)
        return false;
    x = Q.data[Q.front];
    return true;
}

链式队列的实现

定义两个指针，一个指向队首，一个指向队尾

typedef struct LinkNode{
    int data;
    struct LinkNode *next;
}LinkNode;

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

初始化

#include 

#define MaxSize 10
using namespace std;

typedef struct LinkNode{
    int data;
    struct LinkNode *next;
}LinkNode;

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

void InitQueue(LinkQueue &Q){
    Q.front=Q.rear=(LinkNode *) malloc(sizeof(LinkNode));
    Q.front->next=NULL;
}

int main() {
    LinkQueue Q;
    InitQueue(Q);
}

入队

void Push(LinkQueue &Q,int x){
    LinkNode *s=(LinkNode *) malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;
    Q.rear=s;
}

出队

bool Pop(LinkQueue &Q,int &x){
    if (Q.rear==Q.front)
        return false;
    LinkNode *p=Q.front->next;
    x=p->data;
    Q.front->next=p->next;
    if (Q.rear==p)
        Q.rear=Q.front;
    free(p);
    return true;
}