排队求平均等待时间c++

排队求平均等待时间c是指在队列中等待的人平均需要等待多长时间才能被服务。计算平均等待时间的方法是将每个人等待的时间相加，然后除以总人数。

首先，我们需要知道队列中每个人等待的时间。假设每个人进入队列的时间都是随机的，那么我们可以通过模拟来计算每个人的等待时间。首先记录每个人进入队列的时间，然后记录每个人离开队列的时间，两者相减就是每个人的等待时间。

然后，我们将所有人的等待时间相加，得到总的等待时间。最后，将总的等待时间除以总人数，就得到了平均等待时间c。

除了通过模拟计算平均等待时间，还可以通过排队理论来计算。排队理论是一种数学模型，可以用来分析排队系统的性能。通过排队理论，我们可以得到排队系统的稳定状态下的平均等待时间，这种方法更加精确和有效。

总之，排队求平均等待时间c是一个重要的问题，在现实生活中经常会遇到。我们可以通过模拟或排队理论来计算平均等待时间，以便更好地优化和改进排队系统的性能。

相关问题

窗口排队管理系统c++

窗口排队管理系统是一个比较典型的模拟系统，可以用C++来实现。下面是一个简单的实现思路：

1. 定义一个窗口类，包含窗口编号、服务类型等属性，以及服务开始和结束时间的方法。

2. 定义一个顾客类，包含顾客编号、到达时间、等待时间、服务时间等属性，以及等待和服务的方法。

3. 定义一个队列类，用于存储等待服务的顾客。

4. 在主函数中，首先输入窗口数量和服务类型，然后不断输入顾客到达时间和服务时间，将顾客按到达时间排序后加入队列中。

5. 进入循环，每次循环取出一个窗口和一个顾客，让窗口服务该顾客，将该顾客的等待时间计入总等待时间统计中。

6. 直到所有顾客都被服务完毕，输出平均等待时间即可。

代码实现可以参考以下示例：

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

// 窗口类
class Window {
public:
    int id;          // 窗口编号
    int serveTime;   // 服务时间
    int startTime;   // 服务开始时间
    int endTime;     // 服务结束时间
    int serveType;   // 服务类型
    bool available;  // 是否空闲

    // 构造函数
    Window(int id, int serveType) {
        this->id = id;
        this->serveType = serveType;
        this->available = true;
    }

    // 开始服务
    void startServe(int curTime) {
        this->startTime = curTime;
        this->endTime = curTime + this->serveTime;
        this->available = false;
    }

    // 结束服务
    void endServe() {
        this->available = true;
    }
};

// 顾客类
class Customer {
public:
    int id;          // 顾客编号
    int arriveTime;  // 到达时间
    int waitTime;    // 等待时间
    int serveTime;   // 服务时间

    // 构造函数
    Customer(int id, int arriveTime, int serveTime) {
        this->id = id;
        this->arriveTime = arriveTime;
        this->serveTime = serveTime;
        this->waitTime = 0;
    }

    // 等待服务
    void waitServe(int curTime) {
        this->waitTime = curTime - this->arriveTime;
    }
};

// 队列类
class Queue {
public:
    queue<Customer*> customers; // 存储等待的顾客

    // 添加顾客
    void addCustomer(Customer* customer) {
        this->customers.push(customer);
    }

    // 取出顾客
    Customer* getCustomer() {
        if (this->customers.empty()) {
            return NULL;
        }
        Customer* customer = this->customers.front();
        this->customers.pop();
        return customer;
    }
};

int main() {
    int n, serveType;
    cout << "请输入窗口数量和服务类型(1:普通，2:快速，3:VIP): ";
    cin >> n >> serveType;

    // 初始化窗口
    Window* windows[n];
    for (int i = 0; i < n; i++) {
        windows[i] = new Window(i + 1, serveType);
    }

    // 输入顾客信息
    Queue queue;
    int id = 1, arriveTime, serveTime;
    while (true) {
        cout << "请输入第" << id << "位顾客的到达时间和服务时间(输入-1结束输入): ";
        cin >> arriveTime;
        if (arriveTime == -1) {
            break;
        }
        cin >> serveTime;
        Customer* customer = new Customer(id, arriveTime, serveTime);
        queue.addCustomer(customer);
        id++;
    }

    // 开始服务
    int curTime = 0, totalWaitTime = 0, servedCount = 0;
    while (true) {
        // 遍历窗口，找到空闲窗口和等待时间最短的顾客
        Window* availableWindow = NULL;
        Customer* shortestWaitCustomer = NULL;
        int shortestWaitTime = INT_MAX;
        for (int i = 0; i < n; i++) {
            if (windows[i]->available) {
                Customer* customer = queue.getCustomer();
                if (customer != NULL && customer->arriveTime <= curTime) {
                    customer->waitServe(curTime);
                    if (customer->waitTime < shortestWaitTime) {
                        shortestWaitTime = customer->waitTime;
                        shortestWaitCustomer = customer;
                        availableWindow = windows[i];
                    }
                } else {
                    windows[i]->endServe();
                }
            } else {
                if (windows[i]->endTime == curTime) {
                    windows[i]->endServe();
                    servedCount++;
                    totalWaitTime += windows[i]->startTime - shortestWaitCustomer->arriveTime;
                }
            }
        }

        // 所有顾客都已服务完毕
        if (servedCount == id - 1) {
            break;
        }

        // 空闲窗口和等待时间最短的顾客都找到了
        if (availableWindow != NULL && shortestWaitCustomer != NULL) {
            availableWindow->serveTime = shortestWaitCustomer->serveTime;
            availableWindow->startServe(curTime);
        }

        curTime++;
    }

    // 输出平均等待时间
    double avgWaitTime = (double) totalWaitTime / (id - 1);
    cout << "平均等待时间为: " << avgWaitTime << endl;

    return 0;
}

银行排队模型代码c++

银行排队模型是一种常见的事件驱动模型，它可以用来模拟银行等服务场所的排队情况。以下是一个简单的C++代码实现：

#include <iostream>
#include <queue>
#include <cstdlib>
#include <ctime>

using namespace std;

const int MAX_WINDOW_NUM = 10; // 最大窗口数
const int MAX_CUSTOMER_NUM = 100; // 最大顾客数

// 顾客类
class Customer {
public:
    Customer(int arrive_time = 0, int service_time = 0) :
        arrive_time_(arrive_time), service_time_(service_time) {}
    int arrive_time() const { return arrive_time_; }
    int service_time() const { return service_time_; }
private:
    int arrive_time_; // 到达时间
    int service_time_; // 服务时间
};

// 窗口类
class Window {
public:
    Window() : is_busy_(false), current_customer_(NULL) {}
    bool is_busy() const { return is_busy_; }
    void serveCustomer(Customer& customer) {
        is_busy_ = true;
        current_customer_ = &customer;
    }
    void finishService() {
        is_busy_ = false;
        current_customer_ = NULL;
    }
    Customer* current_customer() const { return current_customer_; }
private:
    bool is_busy_; // 是否忙碌
    Customer* current_customer_; // 当前服务的顾客
};

// 队列系统类
class QueueSystem {
public:
    QueueSystem(int total_service_time, int window_num) :
        total_service_time_(total_service_time), window_num_(window_num),
        current_time_(0), customer_num_(0), total_customer_wait_time_(0) {
        srand(time(NULL));
        for (int i = 0; i < window_num_; ++i) {
            windows_[i] = Window();
        }
    }
    void simulate() {
        while (current_time_ < total_service_time_) {
            generateCustomer();
            updateWindow();
            ++current_time_;
        }
        printStatistics();
    }
private:
    void generateCustomer() {
        if (rand() % 3 == 0) { // 每秒钟有1/3的概率生成一个新顾客
            Customer customer(current_time_, rand() % 5 + 1);
            customer_queue_.push(customer);
            ++customer_num_;
        }
    }
    void updateWindow() {
        for (int i = 0; i < window_num_; ++i) {
            if (windows_[i].is_busy()) { // 如果窗口正在服务顾客
                Customer* customer = windows_[i].current_customer();
                if (current_time_ - customer->arrive_time() >= customer->service_time()) { // 如果顾客服务结束
                    windows_[i].finishService();
                    total_customer_wait_time_ += current_time_ - customer->arrive_time() - customer->service_time();
                }
            }
            if (!windows_[i].is_busy() && !customer_queue_.empty()) { // 如果窗口空闲且队列中有顾客
                Customer customer = customer_queue_.front();
                customer_queue_.pop();
                windows_[i].serveCustomer(customer);
            }
        }
    }
    void printStatistics() {
        cout << "顾客总数：" << customer_num_ << endl;
        cout << "平均等待时间：" << (double)total_customer_wait_time_ / customer_num_ << endl;
    }
private:
    int total_service_time_; // 总服务时间
    int window_num_; // 窗口数
    int current_time_; // 当前时间
    int customer_num_; // 顾客总数
    int total_customer_wait_time_; // 顾客总等待时间
    Window windows_[MAX_WINDOW_NUM]; // 窗口数组
    queue<Customer> customer_queue_; // 顾客队列
};

int main() {
    QueueSystem queue_system(60, 3); // 总服务时间为60秒，3个窗口
    queue_system.simulate();
    return 0;
}