• 数据结构作业2 用队列模拟银行排队的情况


    ================数据结构作业2 ------ 用队列模拟银行排队的情况============

    直接上代码

    ----------------------queue.h----------------------------------------

    //队列的接口
    
    #ifndef QUEUE_H_
    #define QUEUE_H_
    
    class Customer
    {
    private:
        long arrive;//到达的时间
        long processTime;//办理业务的时间
    public:
        Customer():arrive(0),processTime(0){}
        void set(long when);//设置时间 
        
        long when() const//返回到达的时间 
        {
            return arrive;
        } 
        
        int proTime() const//返回办理业务的时间 
        {
            return processTime;
        }
    };
    
    typedef Customer Item;//取个别名
    
    //队列类
    class Queue
    {
    private:
        struct Node//内嵌结构体 
        {
            Item item;
            struct Node * next; 
        };
        enum {Q_SIZE = 10}; //队列的长度 
        
        //成员变量
        Node* front;//队首 
        Node* rear; //队尾
        int items;//队列当前数量
        const int qsize;//队列的最大容量
        
        Queue(const Queue &q):qsize(0){}
        Queue& operator=(const Queue &q)
        {
            return *this;
        } 
        
    public :
        Queue(int qs = Q_SIZE);//默认创建一个最大长度的队列 
        ~Queue();
        bool isEmpty() const;
        bool isFull()const ; 
        int queueCount() const;
        bool enqueue(const Item &item);//入队
        bool dequeue(Item &item);//出队 
        
    }; 
    
    #endif
     

    ----------------------queue.cpp----------------------------------------

    #include "queue.h"
    #include <cstdlib>
    
    //使用成员初始化列表初始化成员变量
    //      这种格式只能用于构造函数
    //     必须使用这种格式来初始化非静态const数据成员
    //      必须使用这种格式来初始化引用数据成员 
    Queue::Queue(int qs):qsize(qs)
    {
        front = rear = NULL;
        items = 0; 
    } 
    
    Queue::~Queue()
    {
        Node *temp;
        while(front != NULL)
        {
            temp = front;
            front = front->next;
            delete temp;
        }
    }
    
    bool Queue::isEmpty() const 
    {
        return items == 0;
    }
    
    bool Queue::isFull() const 
    {
        return items == qsize;
    }
    
    int Queue::queueCount() const
    {
        return items; 
    } 
    
    //入队
    bool Queue::enqueue(const Item &item)
    {
        if(isFull())
        {
            return false;
        }
        
        //创建一个节点 
        Node* add = new Node();
        if(add == NULL)
        {
            return false;
        }
        add->item = item;
        add->next = NULL;
        items++;
        
        if(front == NULL)//如果队列为空
        {
            front = add; //直接加到队头 
        } else {
            rear->next = add;//不为空就加到队尾 
        }
        
        rear = add;//将队尾指向最后一个节点 
        
        return true;
    } 
    
    bool Queue::dequeue(Item &item)//这个item用于返回被删除的值 
    {
        if(front == NULL)
        {
            return false;
        }
        
        item = front->item;//让item指向队列的第一个元素
        items--;
        
        Node* temp = front;
        front = front->next;
        delete temp; 
        
        //如果出队后成空队列了就把real置空 
        if(items == 0)
        {
            rear = NULL;
        } 
        
        return true; 
    } 
    
    
    void Customer::set(long when)
    {
        processTime = std::rand()%3 +1;//产生一个1~3之间的随机数
        arrive = when; 
    }

    ---------------------------TestQueue.cpp----------------------------------------

    #include <iostream>
    #include <ctime>
    #include "queue.cpp"
    
    const int MIN_PER_HR = 60;
    
    bool newCustomer(double x);//判断是否会有一个新的客户到来
    
    int main()
    {
        using std::cin;
        using std::cout;
        using std::endl;
        using std::ios_base;
        
        std::srand(std::time(0));
        
        cout <<"中国人民银行考试办理业务了\n";
        cout << "输入队列能容纳的最大人数:";
        int qs;
        cin >> qs;
        Queue line(qs);//创建一个容量为qs的队列line
        
        cout << "输入你需要模拟的小时数:";
        int hours;
        cin >> hours;
        long cyclelimit = MIN_PER_HR*hours;//办理模拟业务的总分钟数 
    
        cout << "输入平均每小时的客户数量:";
        double perhour;
        cin >> perhour;
        double min_per_cust; //平均隔多少分钟来一个客户 
        min_per_cust = MIN_PER_HR/perhour;
        
        Item temp;
        long turnaways = 0;//如果队列满了就客户就会离开的数量 
        long customers = 0;//正常客户数量 
        long served = 0;//已经办理过的客户数量
        int sum_line = 0;//队列累计长度 
        int wait_time = 0;//用户在队列中的等待时间
        long line_wait = 0;//队列的累计等待时间
        
        //开始模拟
        for(int cycle = 1; cycle <= cyclelimit; ++cycle)
        {
            
            if(newCustomer(min_per_cust))//如果有新客户
            {
                cout << ""  << cycle << " 分钟来了一个客户, "; 
                if(line.isFull())
                {
                    cout << "但是没地方排队了,所以离开了......\n";
                    turnaways++;//如果当前队列是满的客户会离开 
                }
                else 
                 {
                     
                    customers++;
                    temp.set(cycle);//给该顾客设置办理业务的时间是1~3之间的随机数
                                    //设置到达的时间是cycle 
                    line.enqueue(temp);//入队 
                    wait_time = temp.proTime();
                    cout << "加入了队列, 他办理业务所需的时间是:" 
                         << temp.proTime() << endl; 
                } 
            }
         
            
            //完成业务办理
            if(wait_time <= 0 && !line.isEmpty())
            {
                cout << ""  << cycle 
                     << " 分钟 **>> 一个用户办理业务完毕**********************\n"; 
                line.dequeue(temp);
                wait_time = temp.proTime();
                line_wait += cycle-temp.when(); 
                served++;
                //cout << "办理好一个业务\n"; 
            }
            
            if(wait_time > 0)
            {
                wait_time--;
            }
            
            sum_line += line.queueCount(); 
        }
        
        ///////////////////////////////////////////////////////////////
        //报告结果
        if(customers > 0)
        {
            cout << "客户总量:" << customers << endl;
            cout << "已处理的客户数量:" << served << endl;
            cout << "没能办理的客户数量:" << turnaways << endl;
            cout << "平均队列长度:";
            cout.precision(2);//保留两位小数
            cout.setf(ios_base::fixed, ios_base::floatfield);
            cout.setf(ios_base::showpoint);//显示小数点
            cout << double(sum_line)/double(cyclelimit) << endl;
            cout << "客户平均等待时间:" << double(line_wait)/served << " 分钟\n";
             
        } else {
            cout << "没有用户!\n";
        }
        
        cout << "\n中国人民银行关门大吉!\n";
            
        return 0;
    } 
    
    //判断是否会有新的客户加入 
    bool newCustomer(double x)
    {
        return (std::rand()*x/RAND_MAX < 1);
    }
     
     

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    测试结果:

    中国人民银行考试办理业务了
    输入队列能容纳的最大人数:3
    输入你需要模拟的小时数:2
    输入平均每小时的客户数量:20
    第4 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第5 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第6 分钟 **>> 一个用户办理业务完毕**********************
    第7 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第8 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第10 分钟 **>> 一个用户办理业务完毕**********************
    第11 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第12 分钟 **>> 一个用户办理业务完毕**********************
    第13 分钟 **>> 一个用户办理业务完毕**********************
    第15 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第16 分钟 **>> 一个用户办理业务完毕**********************
    第17 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第18 分钟 **>> 一个用户办理业务完毕**********************
    第19 分钟 **>> 一个用户办理业务完毕**********************
    第26 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第27 分钟 **>> 一个用户办理业务完毕**********************
    第33 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第35 分钟 **>> 一个用户办理业务完毕**********************
    第38 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第40 分钟 **>> 一个用户办理业务完毕**********************
    第52 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:3
    第55 分钟 **>> 一个用户办理业务完毕**********************
    第56 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第58 分钟 **>> 一个用户办理业务完毕**********************
    第61 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:3
    第62 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第63 分钟 **>> 一个用户办理业务完毕**********************
    第66 分钟 **>> 一个用户办理业务完毕**********************
    第69 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第71 分钟 **>> 一个用户办理业务完毕**********************
    第73 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第74 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第75 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第76 分钟来了一个客户, 但是没地方排队了,所以离开了......
    第76 分钟 **>> 一个用户办理业务完毕**********************
    第77 分钟 **>> 一个用户办理业务完毕**********************
    第78 分钟 **>> 一个用户办理业务完毕**********************
    第83 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:3
    第84 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:1
    第85 分钟 **>> 一个用户办理业务完毕**********************
    第86 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第87 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第89 分钟 **>> 一个用户办理业务完毕**********************
    第90 分钟 **>> 一个用户办理业务完毕**********************
    第92 分钟 **>> 一个用户办理业务完毕**********************
    第93 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第94 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第96 分钟 **>> 一个用户办理业务完毕**********************
    第98 分钟 **>> 一个用户办理业务完毕**********************
    第100 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:2
    第102 分钟 **>> 一个用户办理业务完毕**********************
    第103 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:3
    第106 分钟 **>> 一个用户办理业务完毕**********************
    第111 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:3
    第114 分钟 **>> 一个用户办理业务完毕**********************
    第119 分钟来了一个客户, 加入了队列, 他办理业务所需的时间是:3
    客户总量:28
    已处理的客户数量:27
    没能办理的客户数量:1
    平均队列长度:0.72
    客户平均等待时间:3.15 分钟
    
    中国人民银行关门大吉!
  • 相关阅读:
    C#中的委托和事件(续)【来自张子扬】
    C# 中的委托和事件[转自张子扬]
    .NET多线程编程入门
    python——configparser模块
    logger模块
    python——time模块
    os模块
    python——re模块
    selenium环境搭建
    iOS中的三大定时器
  • 原文地址:https://www.cnblogs.com/CocoonFan/p/2994595.html
Copyright © 2020-2023  润新知