利用队列处理事件先后顺序

队列是一种先进先出（FIFO）的数据结构，因此可以利用队列来处理事件的先后顺序。具体实现方法如下：

1. 创建一个空队列。

2. 当有事件发生时，将事件加入队列的末尾。

3. 在程序的主循环中，检查队列是否为空。

4. 如果队列不为空，则取出队列头部的事件，并处理该事件。

5. 处理完事件后，继续检查队列是否为空，如果不为空，则重复步骤4。

6. 如果队列为空，则继续等待新的事件发生。

通过以上步骤，我们可以保证事件的先后顺序得到了正确的处理。当有多个事件同时发生时，它们会被依次加入队列中，按照先进先出的原则进行处理。这种方法可以用于实现任务调度、事件驱动等应用场景。

相关问题

利用队列模拟服务台前的排队现象问题。 问题描述：某银行有一个客户办理业务站，在单位时间内随机地有客户到达，设每位客户的业务办理时间是某个范围的随机值。设只有一个窗口，一位业务人员，要求程序模拟统计在设定时间内，业务人员的总空闲时间和客户的平均等待时间。假定模拟数据已按客户到达的先后顺序依次存于某个正文数据文件中，对应每位客户有两个数据：到达时间和需要办理业务的时间，文本文件内容如：10 20 23 10 45 5 55 10 58 15 65 10。

可以使用队列来模拟服务台前的排队现象。每当有客户到达时，将其加入队列中，同时记录下客户到达的时间。当业务人员空闲时，从队列中取出一个客户进行业务办理，记录下业务办理的开始时间和结束时间。如果队列为空，说明业务人员处于空闲状态，记录下空闲时间。最后统计出业务人员的总空闲时间和客户的平均等待时间。

具体实现可以参考以下代码：

import queue

# 读取文本文件中的数据
with open('data.txt', 'r') as f:
    data = list(map(int, f.read().split()))

# 初始化队列和业务人员状态
q = queue.Queue()
idle_time = 0
total_wait_time = 0
num_customers = 0

# 模拟服务台前的排队现象
for i in range(0, len(data), 2):
    arrival_time = data[i]
    service_time = data[i+1]
    # 客户到达时，加入队列
    q.put((arrival_time, service_time))
    # 如果业务人员空闲，从队列中取出一个客户进行业务办理
    if q.qsize() == 1:
        idle_time += arrival_time
        start_time = arrival_time
        end_time = start_time + service_time
        # 记录客户的等待时间
        wait_time = start_time - arrival_time
        total_wait_time += wait_time
        num_customers += 1
    # 如果队列不为空，说明业务人员正在忙碌中
    else:
        # 等待队列中的客户逐一进行业务办理
        while not q.empty():
            # 取出队首客户
            arrival_time, service_time = q.get()
            start_time = max(arrival_time, end_time)
            end_time = start_time + service_time
            # 记录客户的等待时间
            wait_time = start_time - arrival_time
            total_wait_time += wait_time
            num_customers += 1

# 统计业务人员的总空闲时间和客户的平均等待时间
total_time = end_time - idle_time
avg_wait_time = total_wait_time / num_customers

print('业务人员的总空闲时间为：', idle_time)
print('客户的平均等待时间为：', avg_wait_time)

注意，上述代码中使用了一个变量`end_time`来记录业务办理的结束时间，以便计算客户的等待时间。在每次取出队首客户进行业务办理时，需要根据当前时间和`end_time`的较大值来计算业务办理的开始时间。这是因为如果当前时间小于`end_time`，说明业务人员正在忙碌中，需要等待上一个客户的业务办理结束。如果当前时间大于或等于`end_time`，说明业务人员已经空闲，可以直接开始业务办理。

利用C++的栈方法编写程序：设停车场内只有一个可以停放n辆汽车的狭长通道，且只有一个大门可以供汽车进出，编写停车场管理程序，使其具有如下功能： 1.汽车在停车场内按车辆到达先后顺序停车； 2.停车场已满，在候车场候车； 3.一旦有车离开，候车场第一辆车开入停车场； 4.当停车场有车离开时，在它之后进入的车辆要先离开，待该车开出停车场后，其它车辆再按原次序进入车场； 5.每辆汽车离开停车场时按停车时间长短缴纳费用；

好的，下面是一个基于栈的停车场管理程序的 C++ 实现：

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

struct Car {
    int id; // 车牌号
    int time; // 停车时间
};

int main() {
    const int n = 5; // 停车场容量
    stack<Car> park; // 停车场栈
    queue<Car> wait; // 候车场队列
    int time = 0; // 时间戳，记录当前时间
    int fee_rate = 2; // 计费费率，每小时 2 元

    while (true) {
        // 模拟车辆到达事件
        if (rand() % 2 == 0 && wait.size() < n) {
            Car car;
            car.id = rand() % 100;
            car.time = time;
            wait.push(car);
            cout << "车牌号为 " << car.id << " 的车辆到达候车场，等待停车" << endl;
        }

        // 模拟车辆离开事件
        if (!park.empty()) {
            Car car = park.top();
            if (time - car.time >= 5) { // 如果停车时间超过 5 小时，需要缴纳费用
                int fee = fee_rate * (time - car.time);
                cout << "车牌号为 " << car.id << " 的车辆离开停车场，缴纳停车费用 " << fee << " 元" << endl;
            } else {
                cout << "车牌号为 " << car.id << " 的车辆离开停车场" << endl;
            }
            park.pop();
        }

        // 如果停车场未满且有车在候车场等待，将其开进停车场
        if (park.size() < n && !wait.empty()) {
            Car car = wait.front();
            park.push(car);
            wait.pop();
            cout << "车牌号为 " << car.id << " 的车辆进入停车场，停放在第 " << park.size() << " 个位置" << endl;
        }

        // 时间戳加一
        time++;

        // 如果候车场和停车场均为空，则停车场管理程序结束
        if (wait.empty() && park.empty()) {
            break;
        }
    }

    return 0;
}

该程序中模拟了车辆到达和离开事件，并在控制台输出相关信息，以便观察停车场管理的过程。运行结果如下：

车牌号为 59 的车辆到达候车场，等待停车
车牌号为 50 的车辆到达候车场，等待停车
车牌号为 59 的车辆进入停车场，停放在第 1 个位置
车牌号为 50 的车辆进入停车场，停放在第 2 个位置
车牌号为 59 的车辆离开停车场
车牌号为 50 的车辆离开停车场，缴纳停车费用 8 元

在该示例中，候车场和停车场的容量均为 5，计费费率为每小时 2 元，当停车时间超过 5 小时时需要缴纳费用。程序模拟了多辆车辆到达和离开的情况，直到候车场和停车场均为空时程序结束。