栈的定义及操作（C++）

顺序栈

顺寻栈的定义

typedef int ElemType;

const int MaxSize = 50;

typedef struct {
    ElemType data[MaxSize];
    int top; //栈顶指针，空栈为-1
} SqStack;

顺序栈的基本操作

void InitStack(SqStack *&);             // 初始化栈
void DestroyStack(SqStack *&);          // 销毁栈
bool StackEmpty(SqStack *);             // 判断栈是否为空
bool Push(SqStack *&, ElemType);        // 进栈
bool Pop(SqStack *&);                   // 出栈
ElemType Top(SqStack *);                // 返回栈顶元素

void InitStack(SqStack * &s) {
    s = (SqStack *)malloc(sizeof(SqStack));
    s -> top = -1;
}

void DestroyStack(SqStack * &s) {
    free(s);
}

bool StackEmpty(SqStack * s) {
    return s -> top == -1;
}

bool Push(SqStack * &s, ElemType e) {
    if (s -> top == MaxSize - 1) return false;
    s -> top++;
    s -> data[s -> top] = e;
    return true;
}

bool Pop(SqStack * &s) {
    if (s -> top == -1) return false;
    s -> top--;
    return true;
}

ElemType Top(SqStack * s) {
    // 栈不为空
    return s -> data[s -> top];
}

顺序栈的基本算法

bool RerverseJudge(vector<ElemType>);                   // 判断数组元素是否为回文串，通常为字符串类型
bool Validseq(vector<ElemType>, vector<ElemType>);      // 判断出栈序列是否为原数组的合法出栈序列

bool RerverseJudge(vector<ElemType> str) {
    SqStack * s;
    InitStack(s);
    for (int i = 0; i < str.size(); i++) Push(s, str[i]);
    for (int i = 0; i < str.size(); i++) {
        ElemType e = Top(s);
        Pop(s);
        if (str[i] != e) return false;
    }
    DestroyStack(s);
    return true;
}

bool Validseq(vector<ElemType> nums, vector<ElemType> target) {
    SqStack * s;
    InitStack(s);
    int j = 0;
    for (int i = 0; i < nums.size(); i++) {
        Push(s, nums[i]);
        while (j < target.size() && Top(s) == target[j]) {
            Pop(s);
            j++;
        }
    }
    bool flag = StackEmpty(s);
    DestroyStack(s);
    return flag;
}

链栈

链栈的定义

typedef int ElemType;

typedef struct LStack {
    ElemType data;
    LStack * next;
} LinkStack;

链栈的基本操作

void InitStack(LinkStack *&);             // 初始化栈
void DestroyStack(LinkStack *&);          // 销毁栈
bool StackEmpty(LinkStack *);             // 判断栈是否为空
bool Push(LinkStack *&, ElemType);        // 进栈
bool Pop(LinkStack *&);                   // 出栈
ElemType Top(LinkStack *);                // 返回栈顶元素

void InitStack(LinkStack * &s) {
    s = (LinkStack *)malloc(sizeof(LinkStack));
    s -> next = NULL;
}

void DestroyStack(LinkStack * &s) {
    LinkStack * pre = s -> next, * p;
    s -> next = NULL;
    while (pre != NULL) {
        p = pre;
        pre = pre -> next;
        free(p);
    }
    free(pre);
}

bool StackEmpty(LinkStack * s) {
    return s -> next == NULL;
}

bool Push(LinkStack * &s, ElemType e) {
    if(s == NULL) return false;
    LinkStack * p = (LinkStack *)malloc(sizeof(LinkStack));
    p -> data = e;
    p -> next = s -> next;
    s -> next = p;
    return true;
}

bool Pop(LinkStack * &s) {
    if(s == NULL || s -> next == NULL) return false;
    LinkStack * p = s -> next;
    s -> next = p -> next;
    free(p);
    return true;
}

ElemType Top(LinkStack * s) {
    // 栈不为空
    return s -> next -> data;
}

栈的经典运算

中缀表达式 链接：栈运算之中缀表达式