栈的定义及操作(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;
}

栈的经典运算

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

  • 0
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值