精华内容
下载资源
问答
  • 银行排队系统

    2018-01-02 14:14:46
    银行排队系统,运用队列知识来模拟排队情况,输入银行关闭时间和排队窗口即可显示
  • 排队论与银行排队系统,详细讲解了一些常见的排队算法
  • C++实现银行排队系统

    2020-08-30 01:42:49
    主要为大家详细介绍了C++实现银行排队系统,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 银行排队系统模拟C++

    2016-04-26 16:56:38
    银行排队系统模拟C++
  • 银行排队系统实现

    2015-10-07 20:07:23
    数据结构实验,用C语言实现银行排队系统,开户,销户,存款,取款
  • C++ 银行排队系统

    2012-11-27 17:14:34
    C++ 写的一个银行排队系统。真实模拟银行排队状况!
  • 银行排队系统源码

    2013-04-10 19:15:48
    银行排队系统源码 linux系统下 下载即可用
  • 银行排队系统

    银行排队系统

    【问题描述】假设银行只有2个窗口对外营业,顾客到银行办理业务,首先要取一个顺序号,然后排队等待叫号。被叫到号的顾客到柜台接受服务,服务完毕后离开。到了下班时间不再接收新来的顾客。顾客分为普通顾客和VIP顾客,VIP顾客有优先权,即可以先得到服务。编一算法模拟银行的每个窗口一天各有多少顾客接受了服务,其中有多少个VIP顾客;并按逆序输出接受服务的普通顾客和VIP顾客的顺序号。
    【问题分析】
    顾客到银行办理业务,必须按照先来先得到服务的原则,因此可以把顾客信息用一个队列来存储,顾客到达后先取号,然后进入队列(插入队尾)等待;被叫到号的顾客接受服务,然后离开(队头元素出列);银行下班后不再接收新来的顾客,即将队列中的元素依次出队列。VIP顾客可以优先得到服务,即可以把VIP顾客单独放在一个队列中,当顾客需要接受服务时 ,首先判断VIP队列是否为空,如不为空,则VIP队列的第一个顾客接受服务;当为空时,则普通队列的第一个顾客接受服务。到达银行的顾客的顺序号随机产生(1-100之间)。顾客的等级也可随机产生(比如;1表示VIP顾客;0表示普通顾客)。设置命令:A表示顾客到达银行;D表示顾客离开银行;P表示下班不再接收新顾客。为了逆序输出已接受服务的顾客顺序号,可以设置一个栈,在顾客接受完服务后,将顾客的顺序号存入栈中,待下班后,依次取出栈中元素并输出,即为所求。
    【实现提示】
    本题采用2个带头结点的链队列和一个顺序栈作为存储结构。
    输入设计:当输入命令A时,进行入队操作;当输入D时,进行出队操作;当输入P时,如果排队队列不空,则依次删除所有元素。在删除元素的过程中,把删除的元素同时入栈,并计数。
    输出设计:输出进入银行排队的总人数和逆序输出排队的顾客顺序号。
    说明:可以不按“实现提示”做,由自己任意发挥。

    #include <iostream>
    #include<stdio.h>
    #include<string.h>
    #include<math.h>
    #include<stdlib.h>
    #include<algorithm>
    using namespace std;
    #define STACK_INIT_SIZE 100
    #define STACKINCREMENT 10
    typedef struct node
    {
        ///结点构造
        int date;///顾客顺序号
        struct node *next;///指针域
    } LinkQnode;
    typedef struct
    {
        ///链队列结构
        LinkQnode *front;///队头指针
        LinkQnode *rear;///队队尾指针
    } LinkQueue;
    typedef struct/**顺序栈结构**/
    {
        int *base;
        int *top;
        int Stacksize;
    } SeqStack;
    void InitLinkQueue(LinkQueue *Q1, LinkQueue *Q2)
    {
        Q1->front = (LinkQnode *)malloc(sizeof(LinkQnode));
        Q1->rear = Q1->front;
        Q1->front->next = NULL;
        Q2->front = (LinkQnode *)malloc(sizeof(LinkQnode));
        Q2->rear = Q2->front;
        Q2->front->next = NULL;
    }
    void InitStack(SeqStack *S)
    {
        S->base = (int *)malloc(100 * sizeof(int));
        if(!S->base)
            printf("空间已满\n");
        else
        {
            S->top = S->base;
            S->Stacksize = 100;
        }
    }
    int EnLinkQueue(LinkQueue *Q, int x)
    {
        LinkQnode *Newnode;
        Newnode = (LinkQnode *)malloc(sizeof(LinkQnode));
        if(Newnode != NULL)
        {
            Newnode->date = x;
            Newnode->next = NULL;
            Q->rear->next = Newnode;
            Q->rear = Newnode;
            printf("序号为%d的顾客进入\n", Q->rear->date);
            return 1;
        }
        else
            return 0;
    }
    int DeLinkQueue(LinkQueue *Q, int *x)
    {
        LinkQnode *p;
        if(Q->front == Q->rear)
            return 0;
        p = Q->front->next;
        Q->front->next = p->next;
        if(Q->rear == p)
        {
            Q->rear = Q->front;
        }
        *x = p->date;
        free(p);
        return 1;
    }
    int Push(SeqStack *S, int x)
    {
        if(S->top - S->base == S->Stacksize)
        {
            S->base = (int *)realloc(S->base, (S->Stacksize + 10) * sizeof(int));
            if(S->base == NULL)
                return 0;
            S->top = S->base + S->Stacksize;
            S->Stacksize = S->Stacksize + 10;
        }
        *S->top = x;
        S->top++;
        return 1;
    }
    int IsLQEmpty(LinkQueue *Q)
    {
        if(Q->front == Q->rear)
            return 1;
        else
            return 0;
    }
    int IsEmpty(SeqStack *S)
    {
        if(S->top == S->base)
            return 1;
        else
            return 0;
    }
    int Pop(SeqStack *S, int *x)
    {
        if(S->top == S->base)
            return 0;
        else
        {
            S->top--;
            *x = *S->top;
            return 1;
        }
    }
    void Process(LinkQueue *Q1, LinkQueue *Q2, SeqStack *S)
    {
        char ch;
        int flag, sum = 0, ans = 1, cnt = 0;
        int num1=0,num2=0,num=0;
        printf("------------------银行排队系统模拟------------------\n");
        printf("  A--表示顾客到达\n  D--表示顾客离开\n  P--表示停止顾客进入\n");
        printf("1表示顾客属于VIP顾客,0表示顾客属于普通顾客\n");
        printf("请输入:A/D/P及0/1\n");
        flag = 1;
        while(flag)
        {
            cin >> ch;
            switch(ch)
            {
            case 'A':
                cin >> cnt;
                if(ans <= 2)
                {
                    num1++;
                    num2++;
                    num++;
                    if(cnt == 1)
                    {
                        EnLinkQueue(Q1, num1);
                        Push(S, num);
                        printf("顾客号为%d的VIP顾客正在接受服务\n", num1);
                        //break;
                    }
                    else if(cnt == 0)
                    {
                        EnLinkQueue(Q2, num2);
                        Push(S, num1);
                        printf("顾客号为%d的普通顾客正在接受服务\n", num2);
                        //break;
                    }
                    ans++;
                    break;
                }
                else if(ans > 2)
                {
                    if(cnt == 0)
                    {
                        num++;
                        EnLinkQueue(Q2, num);
                        printf("请顺序号为%d的普通顾客等待\n", num);
                        //break;
                    }
                    else if(cnt == 1)
                    {
                        num++;
                        EnLinkQueue(Q1, num);
                        printf("请顺序号为%d的VIP顾客等待\n", num);
                        //break;
                    }
                }
                break;
            case 'D':
                if(!IsLQEmpty(Q1))//
                {
                    DeLinkQueue(Q1,&num);
                    sum=sum+1;///已接受服务的顾客数
                    printf("请序号为%d的VIP顾客离开\n",num);
                    Push(S,num);
                }
                else if(IsLQEmpty(Q1)&&(!IsLQEmpty(Q2)))
                {
                    DeLinkQueue(Q2,&num);
                    sum=sum+1;
                    printf("请序号为%d的普通顾客离开\n",num);
                }
                else if(IsLQEmpty(Q1)&&IsLQEmpty(Q2))
                {
                    printf("无顾客排队\n");
                }
                break;
            case 'P':
                printf("停止顾客进入\n");
                printf("还在排队的顾客有:\n");
                while(!IsLQEmpty(Q1))
                {
                    DeLinkQueue(Q1,&num);
                    printf("还在排队的VIP顾客号%d\n",num);
                    sum=sum+1;
                    Push(S,num);
                }
                while(!IsLQEmpty(Q2))
                {
                    DeLinkQueue(Q2,&num);
                    printf("还在排队的普通顾客号%d\n",num);
                    sum=sum+1;
                    Push(S,num);
                }
                flag=0;
                break;
            }
        }
        printf("到达银行的顾客人数为%d\n",sum);
        while(!IsEmpty(S))
        {
            Pop(S,&num);
            printf("第%d位顾客,序号为%d\n",sum,num);
            sum--;
        }
    
    }
    int main()
    {
        LinkQueue *Q1, *Q2;
        SeqStack *S;
        Q1 = (LinkQueue *)malloc(sizeof(LinkQueue));
        Q2 = (LinkQueue *)malloc(sizeof(LinkQueue));
        S = (SeqStack *)malloc(sizeof(SeqStack));
        InitLinkQueue(Q1, Q2);
        InitStack(S);
        Process(Q1, Q2, S);
        return 0;
    }
    
    
    展开全文
  • 数据结构课程设计源代码 银行排队系统 使用C++
  • 银行排队系统实现 功能要求: (1) 客户进入排队系统,两种情况 VIP 和普通客户; (2) 客户离开; (3) 查询当前客户前面还有几人; (4) 查询截至目前总共办理多少客户。 输出要求:每进行一次操作后,输出...
  • 介绍了IIC总线芯片基本性能及时序、总线结构,设计了银行排队系统,介绍带IIC总线的芯片PCF8563,通过软件的方法,实现IIC总线在MCS-51系统中的使用,有效利用了现有资源,实现排队功能,提高银行工作效率,减少顾客...
  • 模拟银行排队系统

    千次阅读 2018-04-09 21:18:07
    文章学习自:小项目分析之C++ 实现模拟银行排队使用C++实现银行排队系统一、问题定义与分析问题定义•要解决的问题——银行一天之内的: 1.总客户数 2.客户总逗留时间 3.客户平均逗留时间问题分析•新来的人找个短的...

    文章学习自:小项目分析之C++ 实现模拟银行排队


    使用C++实现银行排队系统

    一、问题定义与分析

    问题定义

    •要解决的问题——银行一天之内的:

    1.总客户数

    2.客户总逗留时间

    3.客户平均逗留时间

    问题分析

    •新来的人找个短的队伍,站在队尾开始排队

    •排在队头的人可以办理业务

    •排队等待办业务的客户是在分散的、随机的时间点到来的

    •特点:离散事件、要排队

    •掌握每个客户到达银行和离开银行这两个时刻

    •统计出客户总数

    •称客户到达银行和客户离开银行这两个时刻发生的事情为“事件”

    •整个模拟按事件发生的先后顺序进行处理

    •事件驱动模拟

    •事件的主要信息是事件类型和事件发生的时刻

    •两类事件:客户到达事件和客户离开事件

    •事件应存储在有序表里

    •有序表按照事件发生的时刻顺序排序

    •队列中的客户的主要信息是客户到达的时刻和客户办理业务所需要的时间

    •队列数量和银行的窗口数量相同

    •每个队列的队头客户就是正在办理业务的客户

    •每个队头客户都存在一个将要发生的客户离开事件



    二、类与算法设计



    类设计

    •有序表选用有序链表,主要操作是插入和删除

    •队列,客户排队

    •类图:用来表示类以及类和类之间的关系的逻辑视图

    •利用类图来记录类的结构,这些类构成了程序的架构

    银行类:

    •要有一个表示队列数量的属性

    •要有一个打烊时间属性

    •要有一个总客户数属性

    •要有一个客户总逗留时间属性

    •聚合一个或多个队列和一个有序链表

    银行类的方法:

    •开门营业

    •处理客户到达事件

    •处理客户离开事件

    •帮助客户选择一个最短的队列

    •确保按照事件发生的时间顺序处理事件



    算法设计

    一共定义三个类事件类Event、客户类Client、银行类Bank

    事件类Event:包含两个成员,事件发生的时间,与时间的类型,类型主要是客户到达事件还是客户离开事件。

    客户类Client:包含两个成员,客户到达的时间与客户停留的时间

    银行类Bank

    包括成员队列数量(即银行窗口数量)、客户人数、客户总逗留时间、打烊时间、以及窗口队列数组、事件链表

    包括方法:

    开门营业void_open_for_day();

    将客户人数、总逗留时间归零,并且随机产生第一个客户的到达时间,加入到事件链表中;

    处理客户到达事件void_handle_arrival_event(Event*event);

    1)产生客户逗留时间,最长为30min

    2)产生下一个客户到达的时间间隔,最长为10min,计算下一个客户到达时间,若时间小于打烊时间,则产生新的客户到达事件插入到事件链表中,并排序

    3)选择窗口队列中最短的队列

    4)生成客户成员,并且插入到最短的队列中

    5)若队列中只有一个客户,则产生客户离开事件,并插入到事件链表中,排序链表(重点)

    6)增加客户总数量

    处理客户离开时间void_handle_leave_event(Event*event);

    1)增加客户总的逗留时间

    2)将客户成员从相应的队列中取出

    3)若队列中仍然有客户成员,则产生该客户的离开事件插入到事件链表中,并排序

    返回最短队列int_find_short_queue();

    时间链表排序void_sort_event();

    仿真函数void_simulation();

    1)调用开门营业函数,初始化各项数据

    2)依次从事件链表中取出事件,并且根据事件的类型调用相应的函数进行处理,知道事件链表为空

    3)返回相应的数据


    源码:

    bank.h 文件

    #ifndef BACK_H
    #define BACK_H
    
    #include<queue>
    #include<list>
    #include <random>
    #include <ctime>
    #include <cstdlib>
    
    using namespace std;
    
    //事件类,成员为事件发生的时间与事件的类型
    struct Event{
        int _occur_time; //时间发生的时间
        int _type; //时间的类型,0代表到达,1-n代表1-n号窗口的离开
        bool operator<(const Event &event)
        {
            return _occur_time < event._occur_time;
        }
    };
    
    //客户类,成员为客户到达的时间和逗留的时间
    struct Client{
        int _arrival_time; //客户到达的时间
        int _stay_time; //客户逗留的时间
    };
    
    //银行类
    class Bank{
    public:
        Bank():_queue_number(4),_client_number(0),_total_stay_time(0),_snoring_time(8*3600)
        {
            _window_queue = new queue<Client>[_queue_number];
            srand((unsigned)time(NULL)); //产生随机数种子,为了使每次生成的随机数不同
        }
    
        Bank(int _work_number, int _close_time);
        ~Bank();
    
        void _simulation();
    
    private:
        int _queue_number; //队列数量,即银行窗口的数量
        int _client_number; //客户总个数
        int _total_stay_time; //客户总逗留时间
        int _snoring_time; //打烊时间
    
        queue<Client> *_window_queue; //银行窗口队列,成员为客户
        list<Event> _event_list; //银行事件的有序链表
    
        void _open_for_day(); //开门营业
        void _handle_arrival_event(Event *event); //处理客户到达事件
        void _handle_leave_event(Event *event); //处理客户离开事件
        int _find_short_queue(); //返回最短队列
        void _sort_event(); //事件链表排序
    };
    
    #endif // BACK_H

    bank.cpp 文件

    #include "back.h"
    #include <random>
    #include <ctime>
    #include <algorithm>
    #include <iostream>
    
    using namespace std;
    
    Bank::Bank(int _work_number, int _close_time):_queue_number(_work_number),_snoring_time(3600*_close_time),
        _client_number(0),_total_stay_time(0)
    {
        _window_queue = new queue<Client>[_queue_number];
        srand((unsigned)time(NULL)); //产生随机数种子,为了使每次生成的随机数不同
    }
    
    Bank::~Bank()
    {
        delete []_window_queue;
    }
    
    void Bank::_open_for_day()
    {
        _client_number = 0;
        _total_stay_time = 0;
    
        int i = rand()%600; //第一个客户在开门十分钟内随机到达
        _event_list.push_back({i, 0});
    }
    
    /* *  1)产生客户逗留时间,最长为30min
     **   2)产生下一个客户到达的时间间隔,最长为10min,计算下一个客户到达时间,若时间小于打烊时间,则产生新的客户到达事件 插入到事件链表中,并排序
     **   3)选择窗口队列中最短的队列
     **   4)生成客户成员,并且插入到最短的队列中
     **   5)若队列中只有一个客户,则产生客户离开事件,并插入到事件链表中,排序链表(重点)
     **   6)增加客户总数量
    *************************/
    void Bank::_handle_arrival_event(Event *event)
    {
        int _stat_time; //逗留时间
        int _next_client_time; //下一个客户到达间隔时间
        _stat_time = rand()%1800 + 1; //随机产生逗留时间
        _next_client_time = rand()%600 + 1; //随机产生下一个客户到达时间
    
        //如果下一个客户的到达时间超过了打烊时间,则不进行处理,否则插入有序数列
        if(_next_client_time + event->_occur_time < _snoring_time)
        {
            Event _next_client_arrival;  //创建下一个客户到达时间
            _next_client_arrival._occur_time = _next_client_time + event->_occur_time;
            _next_client_arrival._type = 0;
            _event_list.push_back(_next_client_arrival);
            _sort_event();
    
        }
    
    
        int i; //选择最短队列
        i = _find_short_queue();
        _window_queue[i].push({event->_occur_time, _stat_time}); //将到达的客户插入到最短队列中
    
        //若队列中只有一个客户时,则产生一个离开时间插入到时间序列中
        if(_window_queue[i].size() == 1)
        {
            _event_list.push_back({event->_occur_time + _stat_time, i+1});  //注意最后为i+1
            _sort_event();
        }
    
        ++_client_number;
    }
    
    /*  1)增加客户总的逗留时间
        2)将客户成员从相应的队列中取出
        3)若队列中仍然有客户成员,则产生该客户的离开事件插入到事件链表中,并排序
    ************************/
    void Bank::_handle_leave_event(Event *event)
    {
        Client client = _window_queue[event->_type - 1].front(); //取出离开事件对用的客户
        _total_stay_time += client._stay_time;
        _window_queue[event->_type - 1].pop(); //客户出队列
        if(!_window_queue[event->_type - 1].empty())
        {
            Client next_client = _window_queue[event->_type - 1].front();
            _event_list.push_back({next_client._arrival_time + next_client._stay_time, event->_type}); //产生新的离开事件插入事件链表中
            _sort_event(); //队列排序
        }
    }
    
    int Bank::_find_short_queue()
    {
        int minSize = 0xFFFF;
        int index = -1;
        for(int i = 0; i < _queue_number; ++i){
            if(_window_queue[i].size() < minSize){
                minSize = _window_queue[i].size();
                index = i;
            }
        }
        return index;
    }
    
    void Bank::_sort_event()
    {
        _event_list.sort([](const Event &event1, const Event &event2){return event1._occur_time < event2._occur_time;});
        _event_list.sort();
    }
    
    /* 1)调用开门营业函数,初始化各项数据
         2)依次从事件链表中取出事件,并且根据事件的类型调用相应的函数进行处理,知道事件链表为空
         3)返回相应的数据
         ***********************/
    void Bank::_simulation()
    {
        _open_for_day(); //开门营业
        Event event;
        while(!_event_list.empty())
        {
            event = _event_list.front(); //取出序列表最前边的事件
            _event_list.pop_front();  //删除序列表最前边的事件
            if(event._type == 0)
                _handle_arrival_event(&event);
            else
                _handle_leave_event(&event);
        }
    
        cout << "客户数:" << _client_number << endl
             << "客户总逗留时间:" << (double)_total_stay_time/3600 << "小时" << endl
             << "平均逗留时间:" << (double)_total_stay_time/(double)(_client_number * 60) << "分钟"
             << endl;
    }
    
    

    main 文件

    #include <iostream>
    #include "back.h"
    
    using namespace std;
    
    int main(int argc, char *argv[])
    {
        Bank bank;
        bank._simulation();
        return 0;
    }
    

    展开全文
  • 银行排队系统实验报告,关于一个银行排队系统的实验报告。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 631
精华内容 252
关键字:

银行排队系统