数据结构中的栈和队列（附实际案例代码）

1.栈和队列的定义和特点

栈（Stack）和队列（Queue）是两种基本的数据结构，它们都属于线性表，即数据元素的存储和访问都是线性的。但它们之间也存在着一些区别。

1.1栈的特点

栈是一种后进先出（LIFO）的数据结构，即最后压入栈的元素将首先被弹出。
栈的操作只能在一端进行，这一端被称为栈顶，而另一端被称为栈底。
栈的基本操作包括入栈（Push）和出栈（Pop），入栈操作将元素放入栈顶，出栈操作将栈顶元素移出。
栈常用于实现函数调用的执行过程、表达式求值、括号匹配等场景。

1.2队列的特点

队列是一种先进先出（FIFO）的数据结构，即最先进入队列的元素将首先被取出。
队列的操作分别在两端进行，队列的一端称为队头，另一端称为队尾。
队列的基本操作包括入队（enqueue）和出队（dequeue），入队操作在队尾添加元素，出队操作从队头移除元素。
队列常用于模拟排队、任务调度、缓冲区管理等场景。

2.实际案例引入

想象一下，你正在开发一个文本编辑器。用户可以在文本编辑器中输入、删除文本，并进行各种编辑操作。为了增强用户体验，你决定实现撤销（Undo）和重做（Redo）功能，以便用户可以回溯到之前的编辑状态或者重新执行已撤销的操作。

在这种情况下，你需要管理文本的修改历史，以确保撤销和重做操作的正确性。这时候，栈（Stack）和队列（Queue）就可以派上用场了。

撤销功能的实现

当用户进行编辑操作时，比如输入文本、删除字符等，你需要将当前的编辑状态保存起来。每当用户执行一个编辑操作时，将该操作对应的编辑状态（比如文本内容、光标位置等）压入栈中。这样，栈顶就是最新的编辑状态，而栈底则是最早的编辑状态。

当用户点击撤销按钮时，从栈顶弹出最新的编辑状态，并将编辑器恢复到该状态。这样用户就可以一步步地回退到之前的编辑状态，实现了撤销功能。

重做功能的实现

当用户执行撤销操作后，有时候会改变主意，希望重新执行之前的操作。这时候就需要实现重做功能。你可以使用另一个栈来存储被撤销的操作，当用户点击重做按钮时，从重做栈中弹出操作，并将其应用到编辑器中，实现重做功能。

以下是c语言的代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>#define MAX_LENGTH 100// 编辑历史结构体
typedef struct {char text[MAX_LENGTH];int cursorPosition;
} EditHistory;// 栈结构定义
typedef struct {EditHistory history[MAX_LENGTH];int top;
} UndoStack;// 初始化栈
void initStack(UndoStack *stack) {stack->top = -1;
}// 判断栈是否为空
int isEmpty(UndoStack *stack) {return stack->top == -1;
}// 判断栈是否已满
int isFull(UndoStack *stack) {return stack->top == MAX_LENGTH - 1;
}// 入栈操作
void push(UndoStack *stack, EditHistory item) {if (isFull(stack)) {printf("Stack overflow\n");return;}stack->history[++stack->top] = item;
}// 出栈操作
EditHistory pop(UndoStack *stack) {if (isEmpty(stack)) {printf("Stack underflow\n");exit(1);}return stack->history[stack->top--];
}// 模拟用户编辑操作，修改文本内容和光标位置
void editContent(char *text, int *cursorPosition) {printf("Enter new text: ");scanf("%s", text);printf("Enter cursor position: ");scanf("%d", cursorPosition);
}// 撤销操作
void undo(UndoStack *undoStack, char *text, int *cursorPosition) {if (isEmpty(undoStack)) {printf("No more undo steps\n");return;}EditHistory history = pop(undoStack);strcpy(text, history.text);*cursorPosition = history.cursorPosition;
}// 重做操作
void redo(UndoStack *redoStack, char *text, int *cursorPosition) {// 在实际情况下，redoStack 应该存储被撤销的操作历史// 这里只是简单演示，直接重新执行了撤销操作的逆向操作EditHistory history;strcpy(history.text, text);history.cursorPosition = *cursorPosition;push(redoStack, history);
}int main() {char text[MAX_LENGTH];int cursorPosition;UndoStack undoStack, redoStack;EditHistory history;// 初始化栈initStack(&undoStack);initStack(&redoStack);// 模拟用户编辑操作editContent(text, &cursorPosition);// 将当前编辑状态压入栈中strcpy(history.text, text);history.cursorPosition = cursorPosition;push(&undoStack, history);// 用户执行撤销操作undo(&undoStack, text, &cursorPosition);// 用户执行重做操作redo(&redoStack, text, &cursorPosition);return 0;
}

3. 栈的表示和操作的实现

栈是一种常见的数据结构，具有后进先出（LIFO）的特性，它的操作包括入栈（Push）和出栈（Pop）。栈可以通过顺序存储和链式存储两种方式来实现。

3.1栈的类型定义

首先，我们定义栈的基本结构，包括栈的元素类型和栈的大小（对于顺序栈而言）

以下是c语言的代码实现：

#define MAX_SIZE 100// 栈的元素类型
typedef int ElementType;// 栈结构定义
typedef struct {ElementType data[MAX_SIZE];int top; // 栈顶指针
} SeqStack;
对于链栈，我们需要定义栈节点 的结构
// 链栈节点结构
typedef struct StackNode {ElementType data; // 数据域struct StackNode *next; // 指针域
} StackNode;// 链栈结构定义
typedef struct {StackNode *top; // 栈顶指针
} LinkStack;

3.2顺序栈的表示和实现

顺序栈使用数组来存储栈元素，同时维护一个栈顶指针指向栈顶元素。下面是顺序栈的入栈和出栈操作的实现。

以下是c语言的代码实现：

// 初始化栈
void initSeqStack(SeqStack *stack) {stack->top = -1; // 空栈时栈顶指针为-1
}// 判断栈是否为空
int isEmptySeqStack(SeqStack *stack) {return stack->top == -1;
}// 判断栈是否已满
int isFullSeqStack(SeqStack *stack) {return stack->top == MAX_SIZE - 1;
}// 入栈操作
void pushSeqStack(SeqStack *stack, ElementType value) {if (isFullSeqStack(stack)) {printf("Stack overflow\n");return;}stack->data[++stack->top] = value;
}// 出栈操作
ElementType popSeqStack(SeqStack *stack) {if (isEmptySeqStack(stack)) {printf("Stack underflow\n");exit(1);}return stack->data[stack->top--];
}

3.3链栈的表示和实现

链栈使用链表来存储栈元素，每个节点包含数据域和指针域，指向下一个节点。下面是链栈的入栈和出栈操作的实现。

以下是c语言的代码实现：

// 初始化链栈
void initLinkStack(LinkStack *stack) {stack->top = NULL; // 空栈时栈顶指针为NULL
}// 判断链栈是否为空
int isEmptyLinkStack(LinkStack *stack) {return stack->top == NULL;
}// 入栈操作
void pushLinkStack(LinkStack *stack, ElementType value) {StackNode *newNode = (StackNode *)malloc(sizeof(StackNode));if (newNode == NULL) {printf("Memory allocation failed\n");exit(1);}newNode->data = value;newNode->next = stack->top;stack->top = newNode;
}// 出栈操作
ElementType popLinkStack(LinkStack *stack) {if (isEmptyLinkStack(stack)) {printf("Stack underflow\n");exit(1);}StackNode *temp = stack->top;ElementType value = temp->data;stack->top = stack->top->next;free(temp);return value;
}

4 栈与递归

栈在计算机科学中具有重要的应用，尤其是在函数调用和递归方面。在程序执行过程中，每次函数调用都会创建一个栈帧（Stack Frame）来存储函数的局部变量、参数以及返回地址等信息，这些栈帧按照后进先出的顺序存放在栈中，因此栈的特性与函数调用和递归密切相关。

4.1函数调用

当一个函数被调用时，系统需要保存函数的调用信息，以便在函数执行完毕后能够正确返回到调用处继续执行。这些调用信息包括函数的参数、返回地址等，它们会被压入一个称为“调用栈”的栈中。当函数执行完毕后，这些信息会被从调用栈中弹出，从而返回到正确的位置继续执行。

例如，考虑以下递归函数计算阶乘的例子：

int factorial(int n) {if (n == 0 || n == 1)return 1;elsereturn n * factorial(n - 1);
}

4.2递归

递归也是基于栈的思想实现的。当一个函数调用自身时，它会将当前函数的状态（包括参数、返回地址等）压入栈中，然后开始执行。当递归调用结束时，函数的状态会被弹出栈，并返回到上一个调用处继续执行。例如，计算阶乘的递归函数：

int factorial(int n) {if (n == 0) {return 1;} else {return n * factorial(n - 1);}
}

在函数 factorial 被调用时，n 的值和返回地址会被压入栈中。当函数递归调用自身时，新的 n 值和返回地址也会被压入栈中。当递归结束时，函数的状态会被依次弹出栈，直到返回到初始的调用处。

5队列的表示和操作的实现

队列是一种常见的数据结构，具有先进先出（FIFO）的特性，通常使用数组或链表来实现。下面我们将分别介绍数组队列和链表队列的表示和操作实现。

5.1数组队列的表现和实现

使用数组实现队列时，需要记录队头（front）和队尾（rear）的位置。初始时，front 和 rear 都指向数组的首元素。当一个元素被入队时，rear 向前移动一位；当一个元素被出队时，front 向前移动一位。当 rear 等于数组大小时，队列满；当 front 等于 rear 时，队列为空。

#define MAX_SIZE 100// 队列元素类型
typedef int ElementType;// 队列结构定义
typedef struct {ElementType data[MAX_SIZE];int front; // 队头指针int rear; // 队尾指针
} ArrayQueue;

接下来是数组队列的入队和出队操作的实现。

// 初始化队列
void initArrayQueue(ArrayQueue *queue) {queue->front = queue->rear = -1; // 空队列时队头和队尾指针都为-1
}// 判断队列是否为空
int isEmptyArrayQueue(ArrayQueue *queue) {return queue->front == -1;
}// 判断队列是否已满
int isFullArrayQueue(ArrayQueue *queue) {return (queue->rear + 1) % MAX_SIZE == queue->front;
}// 入队操作
void enqueueArrayQueue(ArrayQueue *queue, ElementType value) {if (isFullArrayQueue(queue)) {printf("Queue overflow\n");return;}if (isEmptyArrayQueue(queue))queue->front = queue->rear = 0;elsequeue->rear = (queue->rear + 1) % MAX_SIZE;queue->data[queue->rear] = value;
}// 出队操作
ElementType dequeueArrayQueue(ArrayQueue *queue) {if (isEmptyArrayQueue(queue)) {printf("Queue underflow\n");exit(1);}ElementType value = queue->data[queue->front];if (queue->front == queue->rear)queue->front = queue->rear = -1;elsequeue->front = (queue->front + 1) % MAX_SIZE;return value;
}

5.2链表队列的表现和实现

链表队列使用链表来存储队列元素，每个节点包含数据域和指针域，指向下一个节点。

// 队列节点结构
typedef struct QueueNode {ElementType data; // 数据域struct QueueNode *next; // 指针域
} QueueNode;// 队列结构定义
typedef struct {QueueNode *front; // 队头指针QueueNode *rear; // 队尾指针
} LinkedQueue;

接下来是链表队列的入队和出队操作的实现。

// 初始化链表队列
void initLinkedQueue(LinkedQueue *queue) {queue->front = queue->rear = NULL; // 空队列时队头和队尾指针都为NULL
}// 判断链表队列是否为空
int isEmptyLinkedQueue(LinkedQueue *queue) {return queue->front == NULL;
}// 入队操作
void enqueueLinkedQueue(LinkedQueue *queue, ElementType value) {QueueNode *newNode = (QueueNode *)malloc(sizeof(QueueNode));if (newNode == NULL) {printf("Memory allocation failed\n");exit(1);}newNode->data = value;newNode->next = NULL;if (isEmptyLinkedQueue(queue))queue->front = queue->rear = newNode;else {queue->rear->next = newNode;queue->rear = newNode;}
}// 出队操作
ElementType dequeueLinkedQueue(LinkedQueue *queue) {if (isEmptyLinkedQueue(queue)) {printf("Queue underflow\n");exit(1);}QueueNode *temp = queue->front;ElementType value = temp->data;queue->front = queue->front->next;free(temp);if (queue->front == NULL) // 出队后队列为空，重置队尾指针queue->rear = NULL;return value;
}

6 综合案例

案例一：浏览器历史记录

浏览器通常使用栈来管理历史记录。当你访问一个网页时，该网页会被压入历史记录栈中。当你点击后退按钮时，浏览器会从历史记录栈中弹出当前网页，并将上一个网页展示出来。

#include <stdio.h>
#include <stdlib.h>typedef struct Stack {int size;int top;char **history;
} Stack;void initStack(Stack *stack, int size) {stack->size = size;stack->top = -1;stack->history = malloc(sizeof(char*) * size);if (stack->history == NULL) {printf("内存分配失败。\n");exit(1);}
}int isEmpty(Stack *stack) {return stack->top == -1;
}int isFull(Stack *stack) {return stack->top == stack->size - 1;
}void push(Stack *stack, char *url) {if (isFull(stack)) {printf("栈已满，无法压入新元素。\n");return;}stack->top++;stack->history[stack->top] = strdup(url);
}char *pop(Stack *stack) {if (isEmpty(stack)) {printf("栈为空，无法弹出元素。\n");return NULL;}char *url = stack->history[stack->top];stack->top--;return url;
}int main() {Stack historyStack;initStack(&historyStack, 5);push(&historyStack, "www.example.com");push(&historyStack, "www.example1.com");push(&historyStack, "www.example2.com");char *prevUrl = pop(&historyStack);printf("后退到上一页：%s\n", prevUrl);return 0;
}

案例二：打印任务队列

打印任务队列也是队列的一个实际应用。当你向打印机发送多个打印任务时，它们会被添加到打印任务队列中。打印机会从队列中取出任务进行打印，遵循先进先出的原则。

#include <stdio.h>
#include <stdlib.h>typedef struct Node {char *filename;struct Node *next;
} Node;typedef struct {Node *head;Node *tail;
} Queue;void initQueue(Queue *queue) {queue->head = NULL;queue->tail = NULL;
}void enqueue(Queue *queue, char *filename) {Node *newNode = malloc(sizeof(Node));if (newNode == NULL) {printf("内存分配失败。\n");return;}newNode->filename = strdup(filename);newNode->next = NULL;if (queue->tail == NULL) {queue->head = newNode;queue->tail = newNode;} else {queue->tail->next = newNode;queue->tail = newNode;}
}char *dequeue(Queue *queue) {if (queue->head == NULL) {printf("队列为空，无法出队。\n");return NULL;}Node *temp = queue->head;char *filename = temp->filename;queue->head = temp->next;if (queue->head == NULL) {queue->tail = NULL;}free(temp);return filename;
}int main() {Queue printQueue;initQueue(&printQueue);enqueue(&printQueue, "document1.pdf");enqueue(&printQueue, "document2.pdf");enqueue(&printQueue, "document3.pdf");char *filename = dequeue(&printQueue);printf("正在打印：%s\n", filename);return 0;
}