银行排队系统模拟—数据结构

                          银行排队系统模拟—数据结构

假设某银行有n个窗口对外接待客户，从早晨银行9点开门起到5点关门，不断有客户进入银行，由于每个窗口在某个时刻只能接待一个客户。因此在客户人数众多时需要在每个窗口前顺次排队，对于刚进银行的客户。如果某个窗口的业务员正空闲，则可上前输业务。反之，若个窗口均有客户所占，他便会排在为数最少的队伍后面。编制一个程序模拟银行的这种业务活动并计算一天中客户在银行的平均逗留时间。
首先从题目分析：N个窗口排队，首先就要建立N个队列来存储排队的用户信息 ，然后算出那个队列最短就用户就到那个队伍排队，同时通过随机生成他办理业务的时间和到来的时间，通过计算用户的到来时间和离开时间就可以计算出某个用户在银行的逗留时间 ；话不多说直接上代码。

1，首先定义队列，存储用户的到达时间，离开时间，，等待时间，办理业务时间，开始办理时间

typedef struct Node
{
    int arrivd_time; //到达时间
    int wait_time;  //等待时间
    int leave_time; //离开时间
    int business_time; //办理业务时间
    int star_time;   //开始办理时间
    Node *next;
}Time_data;
struct Queue
{
    Node *front; 
    Node *rear;
};
//队列初始化
void initQueue(Queue *q)
{
    q->front = q->rear = (Node *)malloc(sizeof(Node));
    if (!q->front)
    {
        return;
    }
    q->front->next = NULL;
}
//判断队空
int isEmpty(Queue *q)
{
    if (q->front == q->rear)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}
//入队
void Enqueue(Queue *q, Time_data *data)
{
    Node *repareInsert = (Node *)malloc(sizeof(Node));
    Time_data *temp_data = data;
    if (repareInsert == NULL)
    {
        exit(0);
    }
    q->rear->arrivd_time = temp_data->arrivd_time;
    q->rear->wait_time = temp_data->wait_time;
    q->rear->leave_time = temp_data->leave_time;
    q->rear->business_time = temp_data->business_time;
    q->rear->star_time = temp_data->star_time;
    q->rear->next = repareInsert;
    q->rear = repareInsert;
}

2，定义一个数组存放四个队列并初始化

Queue first_queue, second_queue, three_queue,five_queue;//定义四个队列
Queue queue[QUEUE_SUM] = { first_queue ,second_queue ,three_queue,five_queue };
//初始化队列
for (int i = 0; i < QUEUE_SUM; i++)
    {
        initQueue(&queue[i]);
    }

下面是主函数，由用户输入银行上下班时间，计算营业多长时间Total_time,如何当前时间小于关门的时间，就一直进入customer_into();函数，用户不断的进来

 #define FALSE 0
#define TRUE 1
#define QUEUE_SUM 4  //窗口的数量

int rand_business_time=0, rand_wait_time=0;//定义办理时间，等待时间变量
int Total_time=0,now_tim=0;//总时间,当前时间
int go_time[4] = {0,0,0,0};//定义数组存储每个窗口最后一位办理完业务的时间
int sum_nan[4] = {0,0,0,0};//定义数组存储每个窗口排队的人数
int Sign=TRUE;  //是否关门标志位
float Sum_Wait_Time=0.0;  //等待的总时间
float Sun_Nan=0.0;  //总人数
int open_time;//开门时间
int off_time; //关门时间
int main()
{
    Prompted();
    printf("输入银行的24小时制营业时间:如营业时间为9:00--17:00，则应输入:9,17\n");
    scanf("%d,%d", &open_time,&off_time);
    Total_time = (off_time - open_time) * 60;//计算银行总营业多少分钟
    for (int i = 0; i < QUEUE_SUM; i++)
    {
        initQueue(&queue[i]);//初始化队列
    }
    printf("在银行关门前办理完的客户\n");
    while (Total_time>now_time)
    {
        customer_into(); //客户进入函数
    }
    printf("银行关门时间到不再接收客人\n\n");
    for (int i = 0; i < QUEUE_SUM; i++)
    {
        DisposeQueue(&queue[i],i);//输入在银行关门前还没有办理完业务的客户信息
    }
    printf("平均时间为%.2f分钟",Sum_Wait_Time/Sun_Nan);  /*通过各个客户的总等待时间总和/总人数算出逗留平均时间*/
    _getch();
    return 0;
}

下面的客户进来函数，首先通过生成两个随机数 rand_business_time办理业务的时间，rand_wait_time这个人用户与上一个用户进来银行的时间差，其他的下面注释已经写的很清楚了

//用户进队函数
void customer_into() {
    int which_queue_free = 0;
    rand_time();//获取两个随机数
    Leave_Queue();//查询各个队列的队首的那个客户是否已经办理完业务
    Leave_Queue();//如何办理完就出队，进行四个查询，是因为有可能下一个用户到来前某个队列
    Leave_Queue();//有多个用户办理完业务，离开。因为每个用户到来的时间间隔控制在五分钟内
    Leave_Queue();//用户办理时间控制在1分钟到30分钟内所以四次判断即可
    which_queue_free = Fing_Queue_free();//获取那个队列最短
    if (Sign)//判断是否已经到了关门时间
    {
        Time_data *data;  //定义一个结构体
        data = (Time_data*)malloc(sizeof(Time_data)); 
        data->arrivd_time = now_time;//存储用户到来的时间
        data->business_time = rand_business_time;//存储用户办理业务的时间
        if (go_time[which_queue_free] == 0||now_time>go_time[which_queue_free])
        /*判断当前队列是否为空*/
        {
            data->leave_time = now_time + rand_business_time;//离开时间等现在时间加办理完业务的时间
            data->wait_time = rand_business_time;//逗留时间等于办理业务的时间
            data->star_time = now_time; //开始办理业务时间等于当前时间
        }
        else
        {
        //如果当前队列不为空
            data->leave_time = go_time[which_queue_free] + rand_business_time;//离开时间等于上一个人离开时间加上办理业务的时间
            data->wait_time = go_time[which_queue_free] - now_time + rand_business_time;//逗留时间等于上一个用户办理完业务的时间减去现在的时间加上办理业务的时间
            data->star_time = go_time[which_queue_free];//开始办理业务的时间等于上一个用户办理完业务的时间
        }
        go_time[which_queue_free] = data->leave_time;//存储这个队列最后一位离开的时间
        sum_nan[which_queue_free] = sum_nan[which_queue_free] + 1;//存储这个队列的人数
        Enqueue(&queue[which_queue_free], data);//进队
    }
}

下面是判断哪个队列的队首客户是否已经办理完业务，并进行出队，和随机时间函数

//各个队列办理完业务出队函数
void Leave_Queue() {
    for (int i = 0; i <QUEUE_SUM; i++)
    {
        if(Sign)
        {
            if (!isEmpty(&queue[i]))
            {
                //Leave_Queue(&queue[i]);
                if (Leave_Queue(&queue[i], i))//如何用户出队
                {
                    sum_nan[i]--;该队伍人数减一
                    Sun_Nan++;  //总人数加一
                }

            }
        }
    }
}
//产生随机数时间
void rand_time() {
    srand((unsigned)time(NULL));  //用时间作为种子对随机数进行操作
    rand_business_time = rand() % 30 + 1;  //任何一个客户的办理业务时间在1-30之间
    rand_wait_time = rand() % 5 + 1;   //任何两个客户到达的时间间隔不超过5分钟，1-5
    now_time += rand_wait_time;//当前时间
    if (Total_time <now_time) {//判断是否到了关门时间
        Sign = FALSE;
    }
    Sleep(1000);  //由于随机函数的产生机制导致在一秒以内产生的随机数都是相同的，因此在一次使用Random时需要进行延时
}

下面是出队函数，判断符合条件的队首元素进行出队出来

//出队函数
int Leave_Queue(Queue *q,int i)
{
    Node *FrontTmp = q->front;
    int start=0;
    int leave=0;
    int wait = 0;
    int business = 0;
    int with_me;
    int arr_h = 0;  //到达时间的小时位
    int arr_m = 0;  //到达时间的分钟位

    int lea_h = 0;  //离开时间的小时位
    int lea_m = 0;  //离开时间的分钟位

    int start_h = 0; //开始办理时间的小时位
    int start_m = 0; //开始办理时间的分钟位
    if (FrontTmp->leave_time <= now_time)//判断离开时间是否小于当前时间
    {
        start = FrontTmp->arrivd_time;
        arr_h = open_time + start / 60;
        arr_m = start % 60;

        leave = FrontTmp->leave_time;
        lea_h = open_time + leave / 60;
        lea_m =  leave % 60;

        wait = FrontTmp->wait_time;
        business = FrontTmp->business_time;

        with_me = FrontTmp->star_time;
        start_h = open_time + with_me / 60;
        start_m =  with_me % 60;

        printf("办理窗口：%d 号窗口\t到达：%d:%d \t离开：%d:%d \t等待：%d 分钟\t业务：%d 分钟\t开始办理：%d:%d\n", ++i, arr_h, arr_m, lea_h, lea_m, wait, business, start_h, start_m);
        Sum_Wait_Time = Sum_Wait_Time + wait;
        if (isEmpty(q))//判断队列是否为空
        {
            printf("BUG\n");
            return FALSE;
        }
        if (q->front == q->rear)//如果队列只有一个元素
        {
            q->front = q->rear = NULL;
            return TRUE;
        }
        Node *FrontTmp1 = q->front;//进行出队
        q->front = q->front->next;
        free(FrontTmp1);
        return TRUE;
    }
    return FALSE;
}

最后对银行关门时间到了，还在办理业务的客户和还在排队的客户进行出队处理，还在办理的客户允许继续办理完业务在离开，还在排队的进马上离开

//队的遍历
void DisposeQueue(Queue *q,int i)
{
    Node *FrontTmp = q->front;
    int sun=0;//统计队列的元素的个数
    int Window = i + 1;
    int wait; //逗留时间
    int leave= Total_time;
    int start = 0;
    int leave1 = 0;
    int wait1 = 0;
    int business = 0;
    int with_me;
    int arr_h = 0;  //到达时间的小时位
    int arr_m = 0;  //到达时间的分钟位

    int lea_h = 0;  //离开时间的小时位
    int lea_m = 0;  //离开时间的分钟位

    int start_h = 0; //开始办理时间的小时位
    int start_m = 0; //开始办理时间的分钟位
    while (FrontTmp != q->rear)
    {
        start = FrontTmp->arrivd_time;
        arr_h = open_time + start / 60;
        arr_m =  start % 60;

        leave1 = FrontTmp->leave_time;
        lea_h = open_time + leave1 / 60;
        lea_m =  leave1 % 60;

        wait1 = FrontTmp->wait_time;
        business = FrontTmp->business_time;

        with_me = FrontTmp->star_time;
        start_h = open_time + with_me / 60;
        start_m =  with_me % 60;
        sun++;
        if (FrontTmp->star_time < Total_time)
        {
            printf("银行关门前已经在办理业务的\n");
            wait = FrontTmp->wait_time;
            leave = FrontTmp->leave_time;
            printf("办理窗口：%d 号窗口\t到达：%d:%d \t离开：%d:%d \t等待：%d 分钟\t业务：%d 分钟\t开始办理：%d:%d\n", Window, arr_h, arr_m, lea_h, lea_m, wait1, business, start_h, start_m);
        }
        else
        {
            printf("银行关门后还在排队的\n");
         wait =(Total_time - FrontTmp->arrivd_time);
         leave = Total_time;
         printf("办理窗口：%d 号窗口\t到达：%d:%d \t离开：%d:00\t等待：%d 分钟\t没有办理业务\n\n", Window, arr_h, arr_m, off_time, wait);
        }

        FrontTmp = FrontTmp->next;
        Sum_Wait_Time += wait;//总等待时间
    }
    Sun_Nan = Sun_Nan + sun;//总人数
}

下面是运行结果截图

以上代码如有不足之处，或者需要改进之处，敬请指出。

源码下载链接：http://download.csdn.net/detail/qq_36480491/9849833