【栈与队列】后进先出 vs 先进先出：数据结构的排队游戏

原创 于 2025-11-21 10:33:00 发布 · 463 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#软件开发

1 概述

1.1 案例介绍

在现代软件开发中，数据结构的选择对程序的性能和可维护性有着至关重要的影响。栈和队列作为两种最基本的数据结构，分别适用于不同的场景。理解它们的特性和优劣，能够帮助开发者在实际项目中做出更合理的技术选型，从而优化系统性能。

栈是一种后进先出（LIFO）的线性结构，支持压栈（push）和弹栈（pop）操作。队列是一种先进先出（FIFO）的线性结构，支持入队（enqueue）和出队（dequeue）操作。栈适用于逆序处理的场景，队列适用于需顺序处理的场景。

本案例首先介绍栈和队列的基本概念与操作，最终使用栈和队列完成一个简单的模拟银行排队系统开发系。本案例相关实验将在华为云开发者空间云主机进行，开发者空间云主机为开发者提供了高效稳定的云资源，确保用户的数据安全。云主机当前已适配完整的C/C++开发环境，支持VS Code等多种IDE工具安装调测。

1.2 适用对象

  • 个人开发者
  • 高校学生

1.3 案例时间

本案例总时长预计50分钟。

1.4 案例流程

d02d852664143a87e40baf08da0a054f.png

说明：

  1. 开通开发者空间，搭建C/C++开发环境。
  2. 打开VS Code，编写代码运行程序。

1.5 资源总览

本案例预计花费总计0元。

资源名称规格单价（元）时长（分钟）
开发者空间-云主机4vCPUs | 8GB | ARM | Ubuntu | Ubuntu 24.04 Server 定制版免费50
VS Code1.97.2免费50

2 配置实验环境

2.1 开发者空间配置

面向广大开发者群体，华为开发者空间提供一个随时访问的“开发桌面云主机”、丰富的“预配置工具集合”和灵活使用的“场景化资源池”，开发者开箱即用，快速体验华为根技术和资源。

如果还没有领取开发者空间云主机，可以参考免费领取云主机文档领取。

领取云主机后可以直接进入华为开发者空间工作台界面，点击打开云主机 > 进入桌面连接云主机。

a1aae6ff53aac98855ef597dd6899967.png

552fc96c3b58a06e294e4a760ae719e3.PNG

2.2 配置实验环境

参考案例中心《基于开发者空间，定制C&C++开发环境云主机镜像》“2. 实验环境搭建”、“3. VS Code安装部署”章节完成开发环境、VS Code及插件安装。

ce130591abe73e48832079b65fec477e.PNG

3 栈和队列

3.1 栈的基本概念与操作

后进先出（LIFO）：最后入栈的元素最先出栈。

核心操作：

push()：元素入栈；

pop()：元素出栈；

peek()：查看栈顶元素。

元素入栈：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100
// 栈结构
typedef struct {
    int top;
    int data[MAX_SIZE];
} Stack;

// 检查栈是否已满
bool isStackFull(Stack *s) {
    return s->top == MAX_SIZE - 1;
}
// 入栈操作
void push(Stack *s, int value) {
    if (isStackFull(s)) {
        printf("栈已满，无法添加元素\n");
        return;
    }
    s->data[++s->top] = value;
}

元素出栈：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100
// 栈结构
typedef struct {
    int top;
    int data[MAX_SIZE];
} Stack;

// 检查栈是否为空
bool isStackEmpty(Stack *s) {
    return s->top == -1;
}
// 出栈操作
int pop(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空，无法弹出元素\n");
        return -1;
    }
    return s->data[s->top--];
}

查看栈顶元素：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100
// 栈结构
typedef struct {
    int top;
    int data[MAX_SIZE];
} Stack;

// 检查栈是否为空
bool isStackEmpty(Stack *s) {
    return s->top == -1;
}
// 查看栈顶元素
int peek(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空\n");
        return -1;
    }
    return s->data[s->top];
}

栈的完整代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100
// 栈结构
typedef struct {
    int top;
    int data[MAX_SIZE];
} Stack;
// 初始化栈
void initStack(Stack *s) {
    s->top = -1;
}
// 检查栈是否为空
bool isStackEmpty(Stack *s) {
    return s->top == -1;
}
// 检查栈是否已满
bool isStackFull(Stack *s) {
    return s->top == MAX_SIZE - 1;
}
// 入栈操作
void push(Stack *s, int value) {
    if (isStackFull(s)) {
        printf("栈已满，无法添加元素\n");
        return;
    }
    s->data[++s->top] = value;
}
// 出栈操作
int pop(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空，无法弹出元素\n");
        return -1;
    }
    return s->data[s->top--];
}
// 查看栈顶元素
int peek(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空\n");
        return -1;
    }
    return s->data[s->top];
}
// 打印栈内容
void printStack(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空\n");
        return;
    }
    printf("栈内容 (从顶到底): ");
    for (int i = s->top; i >= 0; i--) {
        printf("%d ", s->data[i]);
    }
    printf("\n");
}

元素入栈、元素出栈、查看栈顶元素、打印栈内容，具体代码操作如下：

Step1：复制以下代码，替换main.cpp文件中的代码。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100
// 栈结构
typedef struct {
    int top;
    int data[MAX_SIZE];
} Stack;
// 初始化栈
void initStack(Stack *s) {
    s->top = -1;
}
// 检查栈是否为空
bool isStackEmpty(Stack *s) {
    return s->top == -1;
}
// 检查栈是否已满
bool isStackFull(Stack *s) {
    return s->top == MAX_SIZE - 1;
}
// 入栈操作
void push(Stack *s, int value) {
    if (isStackFull(s)) {
        printf("栈已满，无法添加元素\n");
        return;
    }
    s->data[++s->top] = value;
}
// 出栈操作
int pop(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空，无法弹出元素\n");
        return -1;
    }
    return s->data[s->top--];
}
// 查看栈顶元素
int peek(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空\n");
        return -1;
    }
    return s->data[s->top];
}
// 打印栈内容
void printStack(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空\n");
        return;
    }
    printf("栈内容 (从顶到底): ");
    for (int i = s->top; i >= 0; i--) {
        printf("%d ", s->data[i]);
    }
    printf("\n");
}

int main() {
    Stack s;
    // 初始化栈
    initStack(&s);
    // 元素入栈
    push(&s, 10);
    push(&s, 20);
    push(&s, 30);
    printStack(&s);
    printf("栈顶元素: %d\n", peek(&s));
    printf("元素出栈: %d\n", pop(&s));
    printStack(&s);
    return 0;
}

Step2：点击编辑器左上角运行按钮直接运行，Terminal窗口可以看到打印内容。

145fa9022a9dc24da5cda1a1857f7654.PNG

3.2 栈的应用实例

括号匹配：检查表达式中的括号是否合法匹配。

实现思路：

  1. 遇到左括号入栈；
  2. 遇到右括号时弹出栈顶元素并检查是否匹配；
  3. 最后检查栈是否为空。

具体代码操作如下：

Step1：复制以下代码，替换main.cpp文件中的代码。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100

// 栈结构
typedef struct {
    int top;
    int data[MAX_SIZE];
} Stack;
// 初始化栈
void initStack(Stack *s) {
    s->top = -1;
}
// 检查栈是否为空
bool isStackEmpty(Stack *s) {
    return s->top == -1;
}
// 检查栈是否已满
bool isStackFull(Stack *s) {
    return s->top == MAX_SIZE - 1;
}
// 入栈操作
void push(Stack *s, int value) {
    if (isStackFull(s)) {
        printf("栈已满，无法添加元素\n");
        return;
    }
    s->data[++s->top] = value;
}
// 出栈操作
int pop(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空，无法弹出元素\n");
        return -1;
    }
    return s->data[s->top--];
}
// 查看栈顶元素
int peek(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空\n");
        return -1;
    }
    return s->data[s->top];
}
// 打印栈内容
void printStack(Stack *s) {
    if (isStackEmpty(s)) {
        printf("栈为空\n");
        return;
    }
    printf("栈内容 (从顶到底): ");
    for (int i = s->top; i >= 0; i--) {
        printf("%d ", s->data[i]);
    }
    printf("\n");
}

bool isBalancedParentheses(char *expression) {
    Stack s;
    initStack(&s);
    for (int i = 0; expression[i] != '\0'; i++) {
        if (expression[i] == '(' || expression[i] == '[' || expression[i] == '{') {
            push(&s, expression[i]);
        } else if (expression[i] == ')' || expression[i] == ']' || expression[i] == '}') {
            if (isStackEmpty(&s)) {
                return false;
            }
            char topChar = pop(&s);
            if ((expression[i] == ')' && topChar != '(') ||
                (expression[i] == ']' && topChar != '[') ||
                (expression[i] == '}' && topChar != '{')) {
                return false;
            }
        }
    }
    return isStackEmpty(&s);
}

int main() {
    printf("\n=== 栈的应用：括号匹配 ===\n");
    char expr1[] = "({[]})";
    char expr2[] = "({[}])";
    printf("表达式: %s -> %s\n", expr1, isBalancedParentheses(expr1) ? "括号匹配" : "括号不匹配");
    printf("表达式: %s -> %s\n", expr2, isBalancedParentheses(expr2) ? "括号匹配" : "括号不匹配");
    return 0;
}

Step2：点击编辑器左上角运行按钮直接运行，Terminal窗口可以看到打印内容。

77c9ea3e61391a2aeec208484cd2aade.PNG

3.3 队列的基本概念与操作

先进先出（FIFO）：最先入队的元素最先出队

核心操作：

enqueue()：元素入队；

dequeue()：元素出队；

front()：查看队首元素。

元素入队：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100
typedef struct {
    int front, rear;
    int data[MAX_SIZE];
} Queue;
// 初始化队列
void initQueue(Queue *q) {
    q->front = -1;
    q->rear = -1;
}
// 检查队列是否为空
bool isQueueEmpty(Queue *q) {
    return q->front == -1;
}
// 检查队列是否已满
bool isQueueFull(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

// 入队操作
void enqueue(Queue *q, int value) {
    if (isQueueFull(q)) {
        printf("队列已满，无法添加元素\n");
        return;
    }
    if (isQueueEmpty(q)) {
        q->front = 0;
    }
    q->rear = (q->rear + 1) % MAX_SIZE;
    q->data[q->rear] = value;
}

元素出队：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100
typedef struct {
    int front, rear;
    int data[MAX_SIZE];
} Queue;
// 初始化队列
void initQueue(Queue *q) {
    q->front = -1;
    q->rear = -1;
}
// 检查队列是否为空
bool isQueueEmpty(Queue *q) {
    return q->front == -1;
}

// 出队操作
int dequeue(Queue *q) {
    if (isQueueEmpty(q)) {
        printf("队列为空，无法弹出元素\n");
        return -1;
    }
    int value = q->data[q->front];
    if (q->front == q->rear) {
        // 队列只有一个元素
        q->front = q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }
    return value;
}

查看队首元素：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100
typedef struct {
    int front, rear;
    int data[MAX_SIZE];
} Queue;
// 初始化队列
void initQueue(Queue *q) {
    q->front = -1;
    q->rear = -1;
}
// 检查队列是否为空
bool isQueueEmpty(Queue *q) {
    return q->front == -1;
}
// 查看队首元素
int front(Queue *q) {
    if (isQueueEmpty(q)) {
        printf("队列为空\n");
        return -1;
    }
    return q->data[q->front];
}

队列的完整代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100
typedef struct {
    int front, rear;
    int data[MAX_SIZE];
} Queue;
// 初始化队列
void initQueue(Queue *q) {
    q->front = -1;
    q->rear = -1;
}
// 检查队列是否为空
bool isQueueEmpty(Queue *q) {
    return q->front == -1;
}
// 检查队列是否已满
bool isQueueFull(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}
// 入队操作
void enqueue(Queue *q, int value) {
    if (isQueueFull(q)) {
        printf("队列已满，无法添加元素\n");
        return;
    }
    if (isQueueEmpty(q)) {
        q->front = 0;
    }
    q->rear = (q->rear + 1) % MAX_SIZE;
    q->data[q->rear] = value;
}
// 出队操作
int dequeue(Queue *q) {
    if (isQueueEmpty(q)) {
        printf("队列为空，无法弹出元素\n");
        return -1;
    }
    int value = q->data[q->front];
    if (q->front == q->rear) {
        // 队列只有一个元素
        q->front = q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }

    return value;
}
// 查看队首元素
int front(Queue *q) {
    if (isQueueEmpty(q)) {
        printf("队列为空\n");
        return -1;
    }
    return q->data[q->front];
}
// 打印队列内容
void printQueue(Queue *q) {
    if (isQueueEmpty(q)) {
        printf("队列为空\n");
        return;
    }
    printf("队列内容 (从队首到队尾): ");
    int i = q->front;
    do {
        printf("%d ", q->data[i]);
        i = (i + 1) % MAX_SIZE;
    } while (i != (q->rear + 1) % MAX_SIZE);
    printf("\n");
}

元素入队、元素出队、查看队首元素、打印队列内容，具体代码操作如下：

Step1：复制以下代码，替换main.cpp文件中的代码。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100
typedef struct {
    int front, rear;
    int data[MAX_SIZE];
} Queue;
// 初始化队列
void initQueue(Queue *q) {
    q->front = -1;
    q->rear = -1;
}
// 检查队列是否为空
bool isQueueEmpty(Queue *q) {
    return q->front == -1;
}
// 检查队列是否已满
bool isQueueFull(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}
// 入队操作
void enqueue(Queue *q, int value) {
    if (isQueueFull(q)) {
        printf("队列已满，无法添加元素\n");
        return;
    }
    if (isQueueEmpty(q)) {
        q->front = 0;
    }
    q->rear = (q->rear + 1) % MAX_SIZE;
    q->data[q->rear] = value;
}
// 出队操作
int dequeue(Queue *q) {
    if (isQueueEmpty(q)) {
        printf("队列为空，无法弹出元素\n");
        return -1;
    }
    int value = q->data[q->front];
    if (q->front == q->rear) {
        // 队列只有一个元素
        q->front = q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }

    return value;
}
// 查看队首元素
int front(Queue *q) {
    if (isQueueEmpty(q)) {
        printf("队列为空\n");
        return -1;
    }
    return q->data[q->front];
}
// 打印队列内容
void printQueue(Queue *q) {
    if (isQueueEmpty(q)) {
        printf("队列为空\n");
        return;
    }

    printf("队列内容 (从队首到队尾): ");
    int i = q->front;
    do {
        printf("%d ", q->data[i]);
        i = (i + 1) % MAX_SIZE;
    } while (i != (q->rear + 1) % MAX_SIZE);
    printf("\n");
}

int main() {
    Queue q;
    // 初始化
    initQueue(&q);
    // 元素入队
    enqueue(&q, 100);
    enqueue(&q, 200);
    enqueue(&q, 300);
    printQueue(&q);
    printf("队首元素: %d\n", front(&q));
    printf("出队元素: %d\n", dequeue(&q));
    printQueue(&q);
    return 0;
}

Step2：点击编辑器左上角运行按钮直接运行，Terminal窗口可以看到打印内容。

950b366c493e37a917edf919e7e77032.PNG

3.4 队列的应用实例

打印任务管理：模拟打印任务的排队和处理。

实现思路：

  1. 新任务入队；
  2. 打印机从队首取出任务处理；
  3. 处理完成后任务出队；
  4. 重复直到队列为空。

具体代码操作如下：

Step1：复制以下代码，替换main.cpp文件中的代码。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#define MAX_SIZE 100

typedef struct {
    int front, rear;
    int data[MAX_SIZE];
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = -1;
    q->rear = -1;
}

// 检查队列是否为空
bool isQueueEmpty(Queue *q) {
    return q->front == -1;
}
// 检查队列是否已满
bool isQueueFull(Queue *q) {
    return (q->rear + 1) % MAX_SIZE == q->front;
}

// 入队操作
void enqueue(Queue *q, int value) {
    if (isQueueFull(q)) {
        printf("队列已满，无法添加元素\n");
        return;
    }

    if (isQueueEmpty(q)) {
        q->front = 0;
    }

    q->rear = (q->rear + 1) % MAX_SIZE;
    q->data[q->rear] = value;
}

// 出队操作
int dequeue(Queue *q) {
    if (isQueueEmpty(q)) {
        printf("队列为空，无法弹出元素\n");
        return -1;
    }

    int value = q->data[q->front];

    if (q->front == q->rear) {
        // 队列只有一个元素
        q->front = q->rear = -1;
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }

    return value;
}

typedef struct {
    int id;
    char document[50];
    int pages;
} PrintJob;

void printJobManagement() {
    Queue printQueue;
    initQueue(&printQueue);
    int jobId = 1;

    printf("\n===== 打印任务管理系统 =====\n");

    // 添加打印任务
    PrintJob job1 = {jobId++, "需求分析.pdf", 15};
    PrintJob job2 = {jobId++, "设计文档.pdf", 28};
    PrintJob job3 = {jobId++, "用户手册.pdf", 22};

    enqueue(&printQueue, job1.id);
    printf("添加任务: %s (ID: %d, 页数: %d)\n", job1.document, job1.id, job1.pages);

    enqueue(&printQueue, job2.id);
    printf("添加任务: %s (ID: %d, 页数: %d)\n", job2.document, job2.id, job2.pages);

    enqueue(&printQueue, job3.id);
    printf("添加任务: %s (ID: %d, 页数: %d)\n", job3.document, job3.id, job3.pages);

    // 处理打印任务
    while (!isQueueEmpty(&printQueue)) {
        int currentJobId = dequeue(&printQueue);
        PrintJob currentJob;

        // 在实际应用中，我们会根据ID查找任务详情
        if (currentJobId == job1.id) currentJob = job1;
        else if (currentJobId == job2.id) currentJob = job2;
        else currentJob = job3;

        printf("\n正在打印: %s (ID: %d)\n", currentJob.document, currentJob.id);
        printf("打印进度: [");
        for (int i = 0; i < 20; i++) {
            printf("#");
            // 模拟打印耗时
            for (int j = 0; j < 10000000; j++);
        }
        printf("] 完成!\n");
        printf("已打印 %d 页\n", currentJob.pages);
    }

    printf("\n所有打印任务已完成!\n");
}

int main() {
    // 打印任务管理
    printJobManagement();
    return 0;
}

Step2：点击编辑器左上角运行按钮直接运行，Terminal窗口可以看到打印内容。

9954df381bd7680766dbf262c1aa1cb0.PNG

打印内容文本显示：

===== 打印任务管理系统 =====
添加任务: 需求分析.pdf (ID: 1, 页数: 15)
添加任务: 设计文档.pdf (ID: 2, 页数: 28)
添加任务: 用户手册.pdf (ID: 3, 页数: 22)

正在打印: 需求分析.pdf (ID: 1)
打印进度: [####################] 完成!
已打印 15 页

正在打印: 设计文档.pdf (ID: 2)
打印进度: [####################] 完成!
已打印 28 页

正在打印: 用户手册.pdf (ID: 3)
打印进度: [####################] 完成!
已打印 22 页

所有打印任务已完成!

打印内容截图：

a322eeaf99c3bd317d227cad241117d1.PNG

4 综合案例：银行排队系统

4.1 数据结构选择

队列：存储排队客户（先进先出原则）

栈：记录已办理业务的客户（后进先出原则）

客户结构体：

struct Customer {
    int id;           // 客户编号 
    int arrivalTime;   // 到达时间
    int serviceTime;  // 办理时长 
};

4.2 核心功能

  1. 随机生成客户；
  2. 给客户分配随机服务时间（随机服务时长1-5个时间单位）；
  3. 客户加入等待队列；
  4. 检查窗口状态，空闲窗口从队列头部获取客户；
  5. 服务完成后记录压入历史栈。

4.3 代码实现及验证

Step1：复制以下代码，替换main.cpp文件中的代码。

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
// 客户结构体 
struct Customer {
    int id;
    int arrivalTime;
    int serviceTime;
};
// 队列实现
struct Queue {
    struct Customer data[MAX_SIZE];
    int front, rear;
};
// 栈实现 
struct Stack {
    struct Customer data[MAX_SIZE];
    int top;
};
// 初始化队列 
void initQueue(struct Queue *q) {
    q->front = q->rear = -1;
}
// 入队操作
void enqueue(struct Queue *q, struct Customer c) {
    if (q->rear == MAX_SIZE - 1) {
        printf("队列已满！\n");
        return;
    }
    if (q->front == -1) q->front = 0;
    q->data[++q->rear] = c;
}
// 出队操作 
struct Customer dequeue(struct Queue *q) {
    if (q->front == -1 || q->front > q->rear) {
        printf("队列为空！\n");
        exit(1);
    }
    return q->data[q->front++];
}
// 初始化栈
void initStack(struct Stack *s) {
    s->top = -1;
}
// 入栈操作 
void push(struct Stack *s, struct Customer c) {
    if (s->top == MAX_SIZE - 1) {
        printf("栈已满！\n");
        return;
    }
    s->data[++s->top] = c;
}
// 模拟银行服务 
void bankSimulation() {
    //srand(currentTime(0)); // 初始化随机数生成器
    struct Queue waitQueue;   // 等待队列
    struct Stack doneStack;   // 已完成业务栈
    initQueue(&waitQueue);
    initStack(&doneStack);
    int currentTime = 0;
    int customerId = 1;
    int windowBusy = 0;       // 窗口状态（0=空闲）
    int serviceEndTime = 0;   // 当前业务结束时间 
    printf("===== 银行排队系统开始模拟 =====\n");
    while (currentTime <= 20) { // 模拟20个时间单位 
        // 新客户到达（随机生成）
        if (rand() % 5 != 0) { 
            struct Customer newCustomer = {
                customerId++,
                currentTime,
                rand() % 5 + 1 // 随机服务时长1-5单位 
            };
            printf("[时间 %d] 新客户 %d 到达\n", currentTime, newCustomer.id);
            enqueue(&waitQueue, newCustomer);
        }
        // 检查窗口状态
        if (!windowBusy && waitQueue.front <= waitQueue.rear) {
            struct Customer next = dequeue(&waitQueue);
            windowBusy = 1;
            serviceEndTime = currentTime + next.serviceTime;
            printf("[时间 %d] 开始服务客户 %d\n", currentTime, next.id);
        }
        // 业务办理完成
        if (windowBusy && currentTime >= serviceEndTime) {
            windowBusy = 0;
            struct Customer completed = waitQueue.data[waitQueue.front - 1];
            push(&doneStack, completed);
            printf("[时间 %d] 客户 %d 办理完成\n", currentTime, completed.id);
        }
        currentTime++;
    }
    // 输出业务记录 
    printf("\n===== 业务办理记录（后进先出） =====\n");
    while (doneStack.top >= 0) {
        struct Customer c = doneStack.data[doneStack.top--];
        printf("客户 %d | 到达时间: %d | 服务时长: %d\n", 
               c.id, c.arrivalTime, c.serviceTime);
    }
}
int main() {
    bankSimulation();
    return 0;
}

Step2：点击编辑器左上角运行按钮直接运行，Terminal窗口可以看到打印内容。

9385f872fd0811b8dad4233865a22cdf.PNG

打印内容文本显示：

===== 银行排队系统开始模拟 =====
[时间 0] 新客户 1 到达
[时间 0] 开始服务客户 1
[时间 1] 新客户 2 到达
[时间 2] 新客户 3 到达
[时间 2] 客户 1 办理完成
[时间 3] 新客户 4 到达
[时间 3] 开始服务客户 2
[时间 4] 新客户 5 到达
[时间 4] 客户 2 办理完成
[时间 5] 新客户 6 到达
[时间 5] 开始服务客户 3
[时间 6] 客户 3 办理完成
[时间 7] 新客户 7 到达
[时间 7] 开始服务客户 4
[时间 8] 新客户 8 到达
[时间 9] 新客户 9 到达
[时间 10] 新客户 10 到达
[时间 10] 客户 4 办理完成
[时间 11] 新客户 11 到达
[时间 11] 开始服务客户 5
[时间 12] 新客户 12 到达
[时间 13] 客户 5 办理完成
[时间 14] 新客户 13 到达
[时间 14] 开始服务客户 6
[时间 15] 新客户 14 到达
[时间 16] 新客户 15 到达
[时间 17] 新客户 16 到达
[时间 17] 客户 6 办理完成
[时间 18] 新客户 17 到达
[时间 18] 开始服务客户 7
[时间 19] 新客户 18 到达
[时间 20] 新客户 19 到达
===== 业务办理记录（后进先出） =====
客户 6 | 到达时间: 5 | 服务时长: 3
客户 5 | 到达时间: 4 | 服务时长: 2
客户 4 | 到达时间: 3 | 服务时长: 3
客户 3 | 到达时间: 2 | 服务时长: 1
客户 2 | 到达时间: 1 | 服务时长: 1
客户 1 | 到达时间: 0 | 服务时长: 2

打印内容截图：

38d8f86400bf3cc8253d5cce6cef4081.PNG

至此，【栈与队列】后进先出 vs 先进先出：数据结构的排队游戏案例已全部完成。

博客
优快云高校俱乐部招募啦，你还在等什么？
01-14 6万+
高校俱乐部招募啦！想成立组织的快看过来。什么是高校俱乐部？优快云高校俱乐部是由优快云发起，大学生自发加入的IT技术学习型组织。俱乐部至今已收到数百所高校成立技术社团的申请，已在全国100多所高校建立技术社团。我们的使命是提高高校学生的技术能力，为行业储备技术人才，为国家数字化战略贡献力量。我们的定位是聚焦高校IT技术爱好者，打造全国最大的高校技术社群。是通过构建系统化的内容和运营体系，将优快云打造成大学生学习、成长和求职的活跃主阵地，形成规模最大的大学生动态简历库。1024程.
博客
基于开发者空间OpenGauss数据库的PLPGSQL实践一
11-21 394
基于开发者空间OpenGauss数据库的PLPGSQL实践一
博客
开发者空间里玩转MySQL之事务与锁
11-21 309
开发者空间里玩转MySQL之事务与锁
博客
基于开发者空间OpenGauss数据库的PLPGSQL实践二
11-21 689
基于开发者空间OpenGauss数据库的PLPGSQL实践二
博客
在云主机实现一键运行Python小游戏
11-21 264
在云主机实现一键运行Python小游戏
博客
仓颉之并发编程的速度激情
11-21 277
仓颉之并发编程的速度激情
博客
仓颉宏实现语言集成查询LINQ
11-21 284
仓颉宏实现语言集成查询LINQ
博客
FastGPT问答系统实战：知识库检索×联网搜索
11-21 409
FastGPT问答系统实战：知识库检索×联网搜索
博客
开发者空间里玩转MySQL之视图与索引
11-21 314
开发者空间里玩转MySQL之视图与索引
博客
基于华为开发者空间从0实现一个MCP Server
11-21 517
基于华为开发者空间从0实现一个MCP Server
博客
仓颉之反射和注解的神秘力量
11-21 823
仓颉之反射和注解的神秘力量
博客
开发者空间里玩转MySQL之存储过程与触发器
11-21 361
开发者空间里玩转MySQL之存储过程与触发器
博客
仓颉之IO操作的交互奥秘
11-21 389
仓颉之IO操作的交互奥秘
博客
开发者空间里玩转MySQL之基础知识与表创建
11-21 378
开发者空间里玩转MySQL之基础知识与表创建
博客
【案例共创】在华为开发者空间高效部署Solo博客
11-21 274
【案例共创】在华为开发者空间高效部署Solo博客
博客
仓颉之编译和构建的奇妙旅程
11-21 413
仓颉之编译和构建的奇妙旅程
博客
昇腾数据探险家：挖掘数据的隐藏宝藏
11-21 1004
昇腾数据探险家：挖掘数据的隐藏宝藏
博客
【案例共创】使用华为开发者空间搭建WordPress博客平台
11-21 1067
【案例共创】使用华为开发者空间搭建WordPress博客平台
博客
开发者空间里玩转MySQL之表数据操作 - 查询
11-21 633
开发者空间里玩转MySQL之表数据操作 - 查询
博客
开发者空间里玩转MySQL之安全与备份
11-21 324
开发者空间里玩转MySQL之安全与备份
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值