C++ 栈和队列实现：顺序栈、链式栈、循环队列、链式队列

设计顺序栈 SeqStack 和链式栈 LinkStack 及相关方法，用于维护栈的基本操作。

a. 顺序栈 SeqStack 的定义：

#define MAX_SIZE 100 // 栈的最大容量

struct SeqStack {
    int data[MAX_SIZE]; // 存储栈元素的数组
    int top; // 栈顶指针，指向栈顶元素的下一个位置
};

b. 顺序栈 SeqStack 的初始化：

void initSeqStack(SeqStack& stack) {
    stack.top = 0; // 初始化栈顶指针为0
}

c. 顺序栈 SeqStack 的入栈操作：

bool pushSeqStack(SeqStack& stack, int element) {
    if (stack.top == MAX_SIZE) {
        return false; // 栈满，无法入栈
    }
    stack.data[stack.top++] = element; // 元素入栈，同时栈顶指针加1
    return true;
}

d. 顺序栈 SeqStack 的出栈操作：

bool popSeqStack(SeqStack& stack, int& element) {
    if (stack.top == 0) {
        return false; // 栈空，无法出栈
    }
    element = stack.data[--stack.top]; // 元素出栈，同时栈顶指针减1
    return true;
}

e. 顺序栈 SeqStack 的获取栈顶元素操作：

bool getTopSeqStack(SeqStack& stack, int& element) {
    if (stack.top == 0) {
        return false; // 栈空，无栈顶元素
    }
    element = stack.data[stack.top - 1]; // 获取栈顶元素
    return true;
}

f. 链式栈 LinkStack 的定义：

struct Node {
    int data; // 存储节点的数据
    Node* next; // 指向下一个节点的指针
};

struct LinkStack {
    Node* top; // 指向栈顶节点的指针
};

g. 链式栈 LinkStack 的初始化：

void initLinkStack(LinkStack& stack) {
    stack.top = nullptr; // 初始化栈顶指针为空
}

h. 链式栈 LinkStack 的入栈操作：

void pushLinkStack(LinkStack& stack, int element) {
    Node* newNode = new Node; // 创建新节点
    newNode->data = element; // 设置新节点的数据
    newNode->next = stack.top; // 将新节点插入链表头部
    stack.top = newNode; // 更新栈顶指针
}

i. 链式栈 LinkStack 的出栈操作：

bool popLinkStack(LinkStack& stack, int& element) {
    if (stack.top == nullptr) {
        return false; // 栈空，无法出栈
    }
    Node* temp = stack.top; // 保存栈顶节点
    element = temp->data; // 获取栈顶节点的数据
    stack.top = temp->next; // 更新栈顶指针
    delete temp; // 释放栈顶节点的内存
    return true;
}

j. 链式栈 LinkStack 的获取栈顶元素操作：

bool getTopLinkStack(LinkStack& stack, int& element) {
    if (stack.top == nullptr) {
        return false; // 栈空，无栈顶元素
    }
    element = stack.top->data; // 获取栈顶节点的数据
    return true;
}

设计循环队列 CirQueue 和链式队列 LinkQueue 及相关方法，用于维护队列的基本操作。

a. 循环队列 CirQueue 的定义：

#define MAX_SIZE 100 // 队列的最大容量

struct CirQueue {
    int data[MAX_SIZE]; // 存储队列元素的数组
    int front; // 队头指针，指向队头元素
    int rear; // 队尾指针，指向队尾元素的下一个位置
};

b. 循环队列 CirQueue 的初始化：

void initCirQueue(CirQueue& queue) {
    queue.front = 0; // 初始化队头指针为0
    queue.rear = 0; // 初始化队尾指针为0
}

c. 循环队列 CirQueue 的入队操作：

bool enqueueCirQueue(CirQueue& queue, int element) {
    if ((queue.rear + 1) % MAX_SIZE == queue.front) {
        return false; // 队满，无法入队
    }
    queue.data[queue.rear] = element; // 元素入队
    queue.rear = (queue.rear + 1) % MAX_SIZE; // 更新队尾指针
    return true;
}

d. 循环队列 CirQueue 的出队操作：

bool dequeueCirQueue(CirQueue& queue, int& element) {
    if (queue.front == queue.rear) {
        return false; // 队空，无法出队
    }
    element = queue.data[queue.front]; // 元素出队
    queue.front = (queue.front + 1) % MAX_SIZE; // 更新队头指针
    return true;
}

e. 循环队列 CirQueue 的获取队头元素操作：

bool getFrontCirQueue(CirQueue& queue, int& element) {
    if (queue.front == queue.rear) {
        return false; // 队空，无队头元素
    }
    element = queue.data[queue.front]; // 获取队头元素
    return true;
}

f. 链式队列 LinkQueue 的定义：

struct Node {
    int data; // 存储节点的数据
    Node* next; // 指向下一个节点的指针
};

struct LinkQueue {
    Node* front; // 指向队头节点的指针
    Node* rear; // 指向队尾节点的指针
};

g. 链式队列 LinkQueue 的初始化：

void initLinkQueue(LinkQueue& queue) {
    queue.front = nullptr; // 初始化队头指针为空
    queue.rear = nullptr; // 初始化队尾指针为空
}

h. 链式队列 LinkQueue 的入队操作：

void enqueueLinkQueue(LinkQueue& queue, int element) {
    Node* newNode = new Node; // 创建新节点
    newNode->data = element; // 设置新节点的数据
    newNode->next = nullptr; // 新节点的下一个节点为空

    if (queue.front == nullptr) {
        queue.front = newNode; // 队空时，更新队头指针
    } else {
        queue.rear->next = newNode; // 更新队尾节点的下一个节点指针
    }
    queue.rear = newNode; // 更新队尾指针
}

i. 链式队列 LinkQueue 的出队操作：

bool dequeueLinkQueue(LinkQueue& queue, int& element) {
    if (queue.front == nullptr) {
        return false; // 队空，无法出队
    }
    Node* temp = queue.front; // 保存队头节点
    element = temp->data; // 获取队头节点的数据
    queue.front = temp->next; // 更新队头指针
    if (queue.front == nullptr) {
        queue.rear = nullptr; // 队空时，更新队尾指针
    }
    delete temp; // 释放队头节点的内存
    return true;
}

j. 链式队列 LinkQueue 的获取队头元素操作：

bool getFrontLinkQueue(LinkQueue& queue, int& element) {
    if (queue.front == nullptr) {
        return false; // 队空，无队头元素
    }
    element = queue.front->data; // 获取队头节点的数据
    return true;
}