初始化顺序栈 2. 插入元素 3. 删除栈顶元素 4. 取栈顶元素 5. 遍历顺序栈 6. 置空顺序栈 7. 初始化并建立链队列 8. 入链队列 9. 出链队列 10. 遍历链队列

1. 初始化顺序栈

顺序栈的初始化包括两部分：动态申请空间和初始化栈顶指针。假设顺序栈的元素类型为 int，栈的最大容量为 MAXSIZE，则初始化顺序栈的代码如下：

#define MAXSIZE 100 // 定义栈的最大容量

typedef struct {
    int data[MAXSIZE]; // 存放栈元素的数组
    int top; // 栈顶指针
} SqStack;

void InitStack(SqStack &S) {
    S.top = -1; // 初始化栈顶指针为 -1，表示栈为空
}

2. 插入元素

在顺序栈中插入元素的操作被称为入栈。入栈的过程包括两部分：栈满检测和元素插入。如果栈已满，则插入操作失败；否则，将元素插入到栈顶，并更新栈顶指针。入栈的代码如下：

bool Push(SqStack &S, int x) {
    if (S.top == MAXSIZE - 1) { // 栈已满，插入失败
        return false;
    }
    S.data[++S.top] = x; // 将元素插入到栈顶，栈顶指针加 1
    return true;
}

3. 删除栈顶元素

在顺序栈中删除元素的操作被称为出栈。出栈的过程包括两部分：栈空检测和元素删除。如果栈已空，则删除操作失败；否则，删除栈顶元素，并更新栈顶指针。出栈的代码如下：

bool Pop(SqStack &S, int &x) {
    if (S.top == -1) { // 栈已空，删除失败
        return false;
    }
    x = S.data[S.top--]; // 删除栈顶元素，栈顶指针减 1
    return true;
}

4. 取栈顶元素

取栈顶元素的操作不涉及元素的插入或删除，只需要返回栈顶元素的值。如果栈已空，则取值操作失败。取值的代码如下：

bool GetTop(SqStack S, int &x) {
    if (S.top == -1) { // 栈已空，取值失败
        return false;
    }
    x = S.data[S.top]; // 返回栈顶元素的值
    return true;
}

5. 遍历顺序栈

遍历顺序栈的过程就是依次输出栈中的所有元素。由于顺序栈是一个后进先出的结构，所以需要从栈顶开始输出。遍历的代码如下：

void TraverseStack(SqStack S) {
    for (int i = S.top; i >= 0; i--) {
        cout << S.data[i] << " ";
    }
    cout << endl;
}

6. 置空顺序栈

置空顺序栈的过程就是将栈顶指针重新设置为 -1，表示栈已为空。置空的代码如下：

void ClearStack(SqStack &S) {
    S.top = -1; // 将栈顶指针置为 -1，表示栈已为空
}

7. 初始化并建立链队列

链队列的初始化需要动态申请一个头结点，并将头结点的指针域置为空。建立链队列需要定义链队列的结点类型，并在插入元素时动态申请结点空间。假设链队列的元素类型为 int，链队列的头结点为 L，则初始化并建立链队列的代码如下：

typedef struct QNode {
    int data; // 存放队列元素的值
    struct QNode *next; // 指向下一个结点的指针
} QNode, *QueuePtr;

typedef struct {
    QueuePtr front; // 指向队头结点的指针
    QueuePtr rear; // 指向队尾结点的指针
} LinkQueue;

void InitQueue(LinkQueue &Q) {
    Q.front = Q.rear = new QNode; // 动态申请头结点空间
    Q.front->next = NULL; // 头结点的指针域置为空
}

8. 入链队列

在链队列中插入元素的操作被称为入队。入队的过程包括两部分：申请结点空间和元素插入。假设要插入的元素值为 x，则入队的代码如下：

void EnQueue(LinkQueue &Q, int x) {
    QueuePtr p = new QNode; // 动态申请结点空间
    p->data = x; // 将元素插入到新结点中
    p->next = NULL; // 新结点的指针域置为空
    Q.rear->next = p; // 将新结点插入到队尾，更新队尾指针
    Q.rear = p;
}

9. 出链队列

在链队列中删除元素的操作被称为出队。出队的过程包括两部分：队空检测和元素删除。如果队已空，则删除操作失败；否则，删除队头元素，并更新队头指针。出队的代码如下：

bool DeQueue(LinkQueue &Q, int &x) {
    if (Q.front == Q.rear) { // 队已空，删除失败
        return false;
    }
    QueuePtr p = Q.front->next; // 获取队头结点
    x = p->data; // 返回队头元素的值
    Q.front->next = p->next; // 删除队头结点，更新队头指针
    if (Q.rear == p) { // 如果队列中只有一个元素，更新队尾指针
        Q.rear = Q.front;
    }
    delete p; // 释放已删除的结点空间
    return true;
}

10. 遍历链队列

遍历链队列的过程就是依次输出队列中的所有元素。由于链队列是一个先进先出的结构，所以需要从队头开始输出。遍历的代码如下：

void TraverseQueue(LinkQueue Q) {
    QueuePtr p = Q.front->next; // 获取队头结点
    while (p != NULL) { // 循环遍历队列中的每个元素
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}