链栈的使用和顺序栈的使用

链栈的使用

#include <iostream>
using namespace std;

// 定义链栈节点结构体
struct ListNode {
    int data;           // 数据域
    ListNode* next;     // 指向下一个节点的指针
};

// 定义链栈结构体
struct Stack {
    ListNode* top;      // 栈顶指针，指向链栈的第一个节点
    int size;           // 链栈的大小
};

// 初始化链栈，返回一个空的链栈结构体
Stack InitStack() {
    Stack S;
    S.top = NULL;       // 初始时栈顶指针为空
    S.size = 0;         // 初始时链栈大小为 0
    return S;
}

// 判断链栈是否为空，如果为空返回 true，否则返回 false
bool IsEmpty(Stack& S) {
    return S.top == NULL && S.size == 0;
}

// 入栈操作，将元素 x 压入到链栈 S 的栈顶
void Push(Stack& S, int x) {
    // 创建新节点
    ListNode* node = new ListNode();
    node->data = x;
    // 新节点指向当前栈顶节点
    node->next = S.top;
    // 栈顶指针指向新节点
    S.top = node;
    // 链栈大小加 1
    S.size++;
}

// 出栈操作，将链栈 S 的栈顶元素弹出，并将其值保存到变量 x 中
void Pop(Stack& S, int& x) {
    if (S.top == NULL) {
        cout << "Stack is empty." << endl;
        return;
    }
    // 保存当前栈顶元素的值
    x = S.top->data;
    // 将栈顶指针指向下一个节点
    ListNode* temp = S.top;
    S.top = S.top->next;
    // 释放当前节点的内存空间
    delete temp;
    // 链栈大小减 1
    S.size--;
}

// 获取链栈 S 的栈顶元素的值，但不弹出它
int GetTop(Stack& S) {
    if (S.top == NULL) {
        cout << "Stack is empty." << endl;
        return -1;
    }
    return S.top->data;
}

// 打印链栈 S 的所有元素
void Print(Stack& S) {
    if (S.top == NULL) {
        cout << "Stack is empty." << endl;
        return;
    }
    ListNode* p = S.top;
    while (p != NULL) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

int main() {
    // 初始化链栈
    Stack S = InitStack();

    // 将元素 1、2、3、4、5 入栈
    for (int i = 1; i <= 5; i++) {
        Push(S, i);
    }

    // 打印链栈中的元素
    Print(S);   // 5 4 3 2 1

    // 获取链栈的栈顶元素
    int top = GetTop(S);
    cout << "Top element is: " << top << endl;     // Top element is: 5

    // 将栈顶元素弹出，并打印剩余元素
    int x;
    Pop(S, x);
    cout << "After popping top element, the stack is: ";
    Print(S);   // 4 3 2 1

    // 判断链栈是否为空，如果非空则打印栈顶元素
    if (!IsEmpty(S)) {
        cout << "Top element is: " << GetTop(S) << endl;     // Top element is: 4
    }

    return 0;
}

值得注意的是这一段。

void Push(Stack& S, int x) {
    // 创建新节点
    ListNode* node = new ListNode();
    node->data = x;
    // 新节点指向当前栈顶节点
    node->next = S.top;
    // 栈顶指针指向新节点
    S.top = node;
    // 链栈大小加 1
    S.size++;
}

这一段相当于在注入新的元素时，链栈的top指针指向新的结点，这样之后才能插入。

顺序栈的使用

#include<iostream>
using namespace std;

const int MaxSize = 100; // 定义栈的最大长度为100

typedef struct {
    int 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 StackFull(SqStack S) {
    if (S.top == MaxSize - 1)
        return true;
    else
        return false;
}

// 元素入栈
bool Push(SqStack &S, int x) {
    if (StackFull(S))
        return false;
    S.top++;
    S.data[S.top] = x;
    return true;
}

// 元素出栈
bool Pop(SqStack &S, int &x) {
    if (StackEmpty(S))
        return false;
    x = S.data[S.top];
    S.top--;
    return true;
}

// 获取栈顶元素
int GetTop(SqStack S) {
    if (StackEmpty(S))
        return -1;
    return S.data[S.top];
}

int main() {
    SqStack s;
    InitStack(s);
    for (int i = 0; i < 10; ++i) {
        Push(s, i);
    }
    while (!StackEmpty(s)) {
        int x;
        Pop(s, x);
        cout << x << " ";
    }
    return 0;
}

这是一段基于数组的顺序栈代码，通过元素下标来确定元素，非常好理解。