队列简单应用

一、问题描述：

1、题目内容：使用队列模拟理发馆的排队现象，通过仿真手法评估其营业状况。

设某理发馆设有N把理发椅，可同时为N位顾客进行理发。当顾客进门时，若有空闲理发椅，则立即入座理发，否则依次排队候理，一旦有顾客理完发离去时，排在队头的顾客便开始理发。假若理发馆每天连续营业T小时（只要有顾客等待，理发椅就不空），求一天内顾客在理发馆内的平均逗留时间（包括理发所需时间和排队等候的时间）与顾客排队等候理发的人数的平均值（排队长度的平均值）。

2、基本要求

（1）当给定理发椅数及营业时间后，由随机数确定顾客理发时间及进门间隔时间，求出一天内顾客在理发馆平均逗留时间、平均队长及关门后收尾工作的时间。

（2）由用户读入的数据仅为理发椅数及营业时间。营业的时间以分钟计，理发椅数及关门时间均为整型，且均大于等于1。

3、测试数据

 理发椅数目N及关门时间由用户读入，第一个顾客进门的时刻为0，之后每个顾客的进门时刻在前一个顾客进门时设定。即在进门事件发生时随即产生两个随机数（DU，IN），DU为进门顾客理发所需的服务时间（简称理发时间）；IN为下一个顾客到达的时间间隔（简称间隔时间）。

二、实现提示：

 R为由随机数发生器的随机数，顾客理发时间和顾客之间的间隔时间不妨假设与R有关，可以由下式确定：

DU=15+R%50    IN=2+R%10

//2013-5-25
//panda

//定义客户类
//Guest.h
#pragma once

#ifndef _GUEST
#define _GUEST

class Guest
{
public:
    int id;                //客户id
    int swtime;            //记录客户进店的时间
    int servertime;        //服务时间
    int ncgtime;        //下个客户到达时间
public:
    Guest();            //默认构造函数
    Guest(int id,int swtime,int stime,int ncgtime);
    Guest(const Guest& g);    //复制构造函数
    Guest& operator=(const Guest& g);    //重载=运算符
};

#endif

//panda
//2013-5-21
//Queue.h
#pragma once
#ifndef _QUEUE
#define _QUEUE
#include"Guest.h"

#ifndef _LNODE
#define _LNODE
//节点结构
struct LNode{
    Guest data;    //值域
    LNode* next;    //连接指针域
};
#endif

class Queue{
private:            //数据定义
    LNode* front;    //队首指针
    LNode* rear;    //队尾指针
public:                //操作
    Queue();                    //初始化队列
    void InitQueue();            //初始化队列，置为空
    void EnQueue(LNode item);    //将新元素插入到队尾
    LNode OutQueue();            //从队列中删除队首元素并返回
    LNode PeekQueue();            //返回队列元素，但是不删除
    bool EmptyQueue();            //判断队列是否为空
    void ClearQueue();            //清除队列，使之为空
    int GetQueueLength();        //获得队列的长度
    //debug
    //void PrintQueue();            //输出队列
};
#endif

//panda
//2013-5-23
//BarBerShop.h
#pragma once
#ifndef _BARBERSHOP
#define _BARBERSHOP
#include"Queue.h"
//barbershop  定义理发店类

class BarBerShop
{
private:
    // 店铺属性
    int chair;                //n把发椅
    Queue* chairqueue;        //n把发椅的相应的队列
    //int startime;            //开始营业时间
    int workhour;            //营业时间长度
    int workingtime;        //营业时间，是分为单位
    static int guestid;        //客户id分配
    //问题
    float atime;                //客人平均逗留时间，等待时间和理发时间   把每个客人的逗留时间加起来，等停止营业的时候在除于中的客人总数
    int samplingtimes;        //采样次数,即循环次数
    float aqlength;            //平均队列长度                          把每次循环的平均队长再除以中的循环次数
    int cworktime;            //关门后收尾工作时间                    
    //状态变量
    int ngct;                //下个客人到达时间，既调用produceguest函数的时间点
    int* stq;                //每条队列的队首客户的服务剩余时间
    int ctime;                //运行中的时间点
    int cuttime;            //下次运行的时间片
    //config setting 
    static const int stime=15;        //服务时间常量
    static const int sftime=50;        //服务时间因子
    static const int ngtime=2;        //下一个客人到达时间常量
    static const int ngftime=10;    //下一个各人到达时间因子
public:
    BarBerShop();            //默认构造函数
    void RunWorking();        //接口，封装了整个营业流程
    void PrintData();        //输出统计数据
protected:
    void PrepareWork();                                //开门前的准备工作，如打扫卫生，清理桌面
    void StartWork();                                //开始营业挣钱娶老婆
    void CloseDoor();                                //关门和老婆吃饭散步去
    int DistributeGuest(Guest& g,int time);            //分发客户，原则是那里人少添加到那个队列里,并返回是第几队队列(虽然理论上，那个队列的人所用的服务时间最少应该添加到那个队列里，但是在真正的生活中，一般都是排在人少的那条队列后面)
    Guest ProduceGuest();                            //返回客户id，和下个客户到达时间,和该客户到达时间
    void QueueWork(Queue queue);                    //每条队列的处理函数
private://辅助函数
    //int MinNumber(int* array,int ngct,int alength);    //求最小值
    int MinQueue(Queue* q,int length);                    //求队列中人最少的一条
    int GetCutTime(int ngct,int* stq,int l);            //ngct下个客户到达时间，stq客户服务剩余时间，l为长度 获取本轮循环的减少时间,返回值表示下次循环是那个对象的执行时间到了 -1表示下个客户到了 
    bool EmptyQueueChair(Queue* q,int l);                //判断队列数组是否全为空
    float GetAverageQueueLength(Queue* q,int l);            //获取队列的平均长度
};
#endif

//panda
//2013-5-25
//Guest.cpp 
#include"Guest.h"
//
//默认构造函数
//
Guest::Guest()
{}
//
//
//
Guest::Guest(int id,int swtime,int stime,int ncgtime)
{
    this->id=id;
    this->swtime=swtime;
    this->servertime=stime;
    this->ncgtime=ncgtime;
}
//
//复制构造函数
//
Guest::Guest(const Guest& g)
{
    id=g.id;
    swtime=g.swtime;
    servertime=g.servertime;
    ncgtime=g.ncgtime;
}
//
//重载=
//
Guest& Guest::operator=(const Guest& g)
{
    id=g.id;
    swtime=g.swtime;
    servertime=g.servertime;
    ncgtime=g.ncgtime;
    return *this;
}

//2013-5-21
//panda
//Queue.cpp
#include<iostream>
#include"Queue.h"
using namespace std;

//Queue成员函数实现

//
//初始化队列，置为空
//
void Queue::InitQueue()
{
    front=rear=NULL;
}
//
//将新元素插入到队尾
//
void Queue::EnQueue(LNode item)
{
    //创建待插入的节点，并申请内存空间 
    LNode* newnode=new LNode();
    //填充数据
    newnode->data=item.data;
    newnode->next=NULL;
    //插入到队尾
    if(rear==NULL)
    {
        //如果链表为空，则新的结点既是队首又是队尾
        front=rear=newnode;
    }else{
        //如链表非空，则新结点被连接到队尾并修改队尾指针
        rear=rear->next=newnode;
    }
}
//
//从队列中删除队首元素并返回
//
LNode Queue::OutQueue()
{
    //如果链队为空，则返回
    if(front==NULL)
    {
        cerr<<"链队为空，无法删除"<<endl;
        exit(1);
    }
    //储存待返回内容
    LNode node;
    node.data=front->data;
    node.next=NULL;
    //队首指针前移
    LNode* delnode=front;
    front=front->next;
    delete delnode;
    //若删除后链队为空，则使队尾指针为空
    if(front==NULL)
    {
        rear=NULL;
    }
    return node;
}
//
//返回队列元素，但是不删除
//
LNode Queue::PeekQueue()
{
    if(front==NULL)
    {
        cerr<<"链队为空，无队首元素。"<<endl;
        exit(1);
    }
    //返回队首元素
    LNode node;
    node.data=front->data;
    node.next=NULL;
    return node;
}
//
//判断队列是否为空
//
bool Queue::EmptyQueue()
{
    return front==NULL;
}
//
//清除队列，使之为空
//
void Queue::ClearQueue()
{
    //队首指针赋给p
    LNode* p=front;
    //依次删除队列中的每个结点
    while (p!=NULL)
    {
        front=front->next;
        delete p;
        p=front;
    }//循环结束后队首指针已经为空
    //置队尾指针为空
    rear=NULL;
}
//
//debug 输出队列
//
//void Queue::PrintQueue()
//{
//    if (front==NULL)
//    {
//        cout<<"队链为空。"<<endl;
//        return ;
//    }
//    LNode *p=front;
//    while (p!=NULL)
//    {
//        cout<<p->data<<" ";
//        p=p->next;
//    }
//}
//
//初始化队列
//
Queue::Queue()
{
    front=rear=NULL;
}
//
//获得队列的元素的长度
//ok
int Queue::GetQueueLength()
{
    int length=0;//存储队列长度
    LNode *p=front;
    while (p!=NULL)
    {
        ++length;
        p=p->next;
    }
    return length;
}

//panda
//2013-5-24

//BarBerShop类的实现
//BarBerShop.cpp
#include"BarBerShop.h"
#include"Guest.h"

#include<iostream>
using namespace std;

//初始化静态成员变量
int BarBerShop::guestid=0;
//
//准备工作，读入数据  呵呵~
//ok
void BarBerShop::PrepareWork()
{
    cout<<"请输入理发店椅子的数目:";
    cin>>chair;
    /*if(chair<=0)
    {
    cout<<"输入数据有误，请重新输入!"<<endl;
    cin>>chair;
    }*/
    //为每张椅子生成一条队列
    chairqueue=new Queue[chair];
    stq=new int[chair];
    cout<<"请输入营业时间（以小时为单位）:";
    cin>>workhour;
    /*if(workhour<8)
    {
    cout<<"请不要偷懒，8个小时都不够，什么时候才能挣够钱娶老婆啊？！亲~,请重新输入"<<endl;
    cin>>workhour;
    }else if (workhour>24)
    {
    cout<<"亲~，一天才25个小时，你要做多久啊？！会累死人的，请重新输入数据"<<endl;
    cin>>workhour;
    }*/
    workingtime=workhour*60;    //化为分钟
    cout<<"营业时间长度为"<<workingtime<<"分钟。"<<endl;
}
//
//分发客户
//ok
int BarBerShop::DistributeGuest(Guest& guest,int time)
{
    //找出队列中最少人的那一条
    int i=MinQueue(chairqueue,chair);
    LNode node;
    node.data=guest;
    node.next=NULL;
    //把结点放在相应的队列
    chairqueue[i].EnQueue(node);
    cout<<"在"<<time<<"时刻，id为"<<guest.id<<"的客户进到店，并排在第"<<i<<"条队列里。"<<endl;
    return i;
}
//
//生产客户
//ok
Guest BarBerShop::ProduceGuest()
{
    Guest nguest;
    //填充guest对象
    nguest.id=guestid++;        
    nguest.ncgtime=ngtime+rand()%ngftime;
    nguest.servertime=stime+rand()%sftime;
    return nguest;
}
//
//开始营业
//
//通过while循环，递减workingtime变量来模拟时间运动，
//并通过各个变量来记得下次该函数的调用时间
//来模拟营业的流程
void BarBerShop::StartWork()
{
    //开始营业
    cout<<"在0点"<<"开始营业，欢迎光临！(方便数据的调试，以0点开始营业)"<<endl;
    //int ngct=0;                    //下个客户到达时间,即调用produceGuest函数的时间
    //int* stq=new int[chair];    //每条队列的客户服务剩余时间
    //清空为0
    for (int i = 0; i < chair; i++)
    {
        stq[i]=0;
    }
    //int cuttime=0;                //每次循环将要减少的时间
    //int ctime=0;                    //当前时间                
    //int workprogress=workingtime;            //工作进度
    while (ctime<workingtime)
    {
        //开始工作
        //相当于执行一轮
        cuttime=GetCutTime(ngct,stq,chair);
        //每循环一次，各个时间片都减去本次的循环时间片
        //workprogress-=cuttime;
        //判断cuttime是否超出范围
        if ((ctime+cuttime)>workingtime)
        {
            cuttime=workingtime-ctime;
        }
        ctime+=cuttime;    
        ngct-=cuttime;
        for (int i = 0; i < chair; i++)
        {
            if (stq[i]!=0)
            {
                stq[i]-=cuttime;
            }

        }
        //具体执行的内容
        //客户部分
        if (ngct==0&&ctime!=workingtime)        //如果下个客户到达的时间到了，且没到关门时间，那就生产一个客户，并投递到相应的队列里
        {
            Guest g=ProduceGuest();
            //stq只记录队列首位客户的服务时间
            g.swtime=ctime;                        //记录进店时间
            int qindex=DistributeGuest(g,ctime);
            if (stq[qindex]==0)
            {
                stq[qindex]=g.servertime;
            }
            //stq[DistributeGuest(g,ctime)]=g.servertime;    //分发客户,并记录服务时间
            ngct=g.ncgtime;    //记录下个客户到达时间
        }
        //理发队列
        for (int i = 0; i < chair; i++)
        {
            //队列里有客户在等，且执行时间到了
            if (stq[i]==0&&chairqueue[i].GetQueueLength()!=0)
            {
                //弹出队首元素
                LNode opnode=chairqueue[i].OutQueue();
                //记录该客户的等待时间
                atime+=(ctime-opnode.data.swtime);
                //更新stq变量
                if (!chairqueue[i].EmptyQueue())
                {
                    stq[i]=chairqueue[i].PeekQueue().data.servertime;
                }

                cout<<"在"<<ctime<<"时刻，第"<<i<<"条队列的id为"<<opnode.data.id<<"的客户理完发。"<<endl;
            }
        }
        //获取队列的平均长度
        aqlength+=GetAverageQueueLength(chairqueue,chair);
        //统计函数调用次数
        ++samplingtimes;
    }
    cout<<"下班时间到了，不接客了，把剩下的客人剪完就吃饭去，好饿啊。"<<endl;
}
//
//求最小值
//
//int BarBerShop::MinNumber(int* array,int ngct,int alength)
//{
//    int min=array[0];
//    //找出数组最小的值
//    for (int i = 1; i < alength; i++)
//    {
//        if (min<array[i])
//        {
//            min=array[i];
//        }
//    }
//    return (min>ngct)?ngct:min;
//}
//
//求最少人的队列
//ok
int BarBerShop::MinQueue(Queue* q,int l)
{
    int index=0;                        //最少人队列下标
    int l0=q[0].GetQueueLength();
    int li;                                //队列长度
    for (int i = 1; i < l; i++)
    {
        li=q[i].GetQueueLength();
        if (l0>li)
        {
            l0=li;
            index=i;
        }
    }
    return index;
}
//
//获取本轮减少时间片,返回下去那个对象的执行时间到了
//ok
int BarBerShop::GetCutTime(int ngct,int *stq,int l)
{
    //只有那些队列的长度不为0的队列的stq值才有效
    int min=ngct;
    //找出数组最小的值
    for (int i = 0; i < l; i++)
    {
        if (chairqueue[i].GetQueueLength()!=0)
        {
            if (min>stq[i])
            {
                min=stq[i];
            }
        }

    }
    return (min>ngct)?ngct:min;
}
//
//开始运作
//
void BarBerShop::RunWorking()
{
    //准备工作
    PrepareWork();
    //开门迎客
    StartWork();
    //关门吃饭
    CloseDoor();
}
//
//构造函数
//ok
BarBerShop::BarBerShop()
{
    chair=0;
    chairqueue=NULL;
    workhour=0;
    workingtime=0;
    atime=0;
    aqlength=0;
    cworktime=0;
    ngct=0;
    stq=NULL;
    ctime=0;
    cuttime=0;
    samplingtimes=0;
    //guestid=0;
}
//
//停止营业，清尾工作
//还是觉得把这个清尾工作写成一个函数，尽管和startwork函数有不少相同的地方
void BarBerShop::CloseDoor()
{
    int bltime=stime+sftime+100;                    //只是为了调用GetCutTime函数，无用参数变量
    while (!EmptyQueueChair(chairqueue,chair))        //只要队列不全为空就一直循环
    {
        cuttime=GetCutTime(bltime,stq,chair);        //获取循环减少的时间片
        ctime+=cuttime;                                //记录时间
        for (int i = 0; i < chair; i++)
        {
            if (stq[i]!=0)
            {
                stq[i]-=cuttime;
            }
        }
        //理发队列
        for (int i = 0; i < chair; i++)
        {
            //队列里有客户在等，且执行时间到了
            if (stq[i]==0&&chairqueue[i].GetQueueLength()!=0)
            {
                //弹出队首元素
                LNode opnode=chairqueue[i].OutQueue();
                //记录客户的等待时间
                atime+=(ctime-opnode.data.swtime);
                //更新stq变量
                if (!chairqueue[i].EmptyQueue())
                {
                    stq[i]=chairqueue[i].PeekQueue().data.servertime;
                }

                cout<<"在"<<ctime<<"时刻，第"<<i<<"条队列的id为"<<opnode.data.id<<"的客户理完发。"<<endl;
            }
        }
        //获取队列的平均长度
        aqlength+=GetAverageQueueLength(chairqueue,chair);
        //统计函数调用次数
        ++samplingtimes;
    }
    cout<<"终于弄好了，下班吃饭。今晚吃什么菜呢？！亲~"<<endl;
}
//
//判断队列数组是否全为空
//
bool BarBerShop::EmptyQueueChair(Queue* q,int l)
{
    for (int i = 0; i < l; i++)
    {
        if (false==q[i].EmptyQueue())
        {
            // 不为空
            return false;
        }
    }
    //为空
    return true;
}
//
//获取队列的平均长度
//
float BarBerShop::GetAverageQueueLength(Queue* q,int l)
{
    int averagelength=0;
    for (int i = 0; i < l; i++)
    {
        averagelength+=q[i].GetQueueLength();
    }
    return (averagelength/(float)l);
}
//
//输出统计数据
//
void BarBerShop::PrintData()
{
    cout<<"关门后的收尾工作时间为："<<ctime-workingtime<<endl
        <<"顾客的平均逗留时间为："<<(atime/(float)guestid)<<endl
        <<"排队队列的平均长度："<<(aqlength/(float)samplingtimes)<<endl;
}

//panda
//2013-5-21
#include<iostream>
#include"BarBerShop.h"

using namespace std;

int main()
{
    BarBerShop bbshop;
    bbshop.RunWorking();
    bbshop.PrintData();
    return 0;
}