队列->队列的应用(银行业务模拟)

文字描述

示意图

代码实现

//
// Created by Zhenjie Yu on 2019-04-13.
//

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>

#define DEBUG

#define RED                  "e[0;31m"
#define L_RED                "e[1;31m"
#define NONE                 "e[0m"

#ifdef DEBUG
#include <stdarg.h>
#define LOG(args...) _log_(__FILE__, __FUNCTION__, __LINE__, ##args);
static void _log_(const char *file, const char *function, int line, const char * format, ...)
{
    char buf[1024] = {0};
    va_list list;
    va_start(list, format);
//    sprintf(buf, "[%s,%s,%d]", file, function, line);
    vsprintf(buf+strlen(buf), format, list);
    sprintf(buf+strlen(buf), "
");
    va_end(list);
    printf(buf);
}
#else
#define LOG
#endif // DEBUG

/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
#define MAXQSIZE 100
typedef struct QElemType{
    int ArrivalTime;
    int Duration;
}QElemType;

typedef struct{
    QElemType *base;
    int front;
    int rear;
}SqQueue;
static int InitQueue(SqQueue *Q);
static int QueueLength(SqQueue Q);
static int EnQueue(SqQueue *Q, QElemType e);
static int DeQueue(SqQueue *Q, QElemType *e);
static int TraverseQueue(SqQueue Q);
static int QueueEmpty(SqQueue Q); //return 0:not empty; -1 empty
static int GetQueueHead(SqQueue Q, QElemType *e);


/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
#define LIST_INIT_SIZE 100
#define LIST_INCREMENT 10

typedef struct Event{
    int OccurTime; //occur time of event.
    int NType;  //event type: 0 arrive; 1-4 queue 1-4 apart.
}Event, ElemType;

typedef struct LinkList{
    ElemType *elem;
    int length;
    int listsize;
}LinkList;
static int InitList(LinkList *L);
static int ListInsert(LinkList *L, ElemType e, int (*fun)(ElemType e1, ElemType e2));
static int ListDelete(LinkList *L, int locate, ElemType *e);
static int compare(ElemType e1, ElemType e2); // return -1(e1.ocurtime < e2.ocurtime), 0, 1
static int ListTraverse(LinkList L);
static int ListEmpty(LinkList L); //return 0:not empty;  -1:empty

/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
typedef LinkList EventList;
EventList ev;           //event table
Event     en;           //event
SqQueue q[4+1];         //four depart queue of customer
QElemType customer;
int TotalTime = 0;      //the total time of spend of all custmers
int CustomerNum = 0;    //the number of custmer
int CloseTime = 50;
static int OpenForDay(){
    TotalTime = 0;
    CustomerNum = 0;
    if(InitList(&ev)<0){
        LOG("error:init event list error!");
        return -1;
    }
    int i = 1;
    for(i=1; i<=4; i++){
        if(InitQueue(&q[i]) < 0){
            LOG("error:init queue %d error!", i);
            return -1;
        }
    }
    en.OccurTime = 0;
    en.NType = 0;
    if(ListInsert(&ev, en, compare)<0){
        LOG("error:insert event(%d,%d) error!", en.OccurTime, en.NType);
        return -1;
    }
}

static int Minimum(SqQueue qList[], int start, int end)
{
    int i = 0;
    int ret = start;
    for(i=start; i<=end; i++){
        if(QueueLength(qList[i]) < QueueLength(qList[ret])){
            ret = i;
        }
    }
    return ret;
}
static int CustomerArrived(void){
    srand((unsigned)time(NULL));
    CustomerNum += 1;
    int durtime = rand()%29+1;  //1-30
    int intertime = rand()%4+1; //1-5
    int t = en.OccurTime + intertime;
    int i = 0;
    Event event;
    QElemType qe;
    if(t<CloseTime){
        //Insert to event list
        event.NType = 0;
        event.OccurTime = t;
        if(ListInsert(&ev, event, compare)<0){
            LOG("error:fail when insert event(%d,%d)!", event.OccurTime, event.NType);
            return -1;
        }
    }
    i = Minimum(q, 1, 4);
    qe.ArrivalTime = en.OccurTime;
    qe.Duration = durtime;
    EnQueue(&q[i], qe);
    if(QueueLength(q[i]) == 1){
        event.OccurTime = en.OccurTime+durtime;
        event.NType = i;
        if(ListInsert(&ev, event, compare)<0){
            LOG("error:fail insert (%d,%d) to List", event.OccurTime, event.NType);
            return -1;
        }
    }
    return 0;
}

static int CustomerDeparture(void){
    int i = en.NType;
    Event event;
    if(DeQueue(&q[i], &customer)<0){
        LOG("error:fail when delete from queue %d", i);
        return -1;
    }
    TotalTime += (en.OccurTime - customer.ArrivalTime);
    if(!QueueEmpty(q[i])){
        if(GetQueueHead(q[i], &customer)<0){
            LOG("error:fail when gethead from queue %d", i);
            return -1;
        }
        event.OccurTime = en.OccurTime+customer.Duration;
        event.NType = i;
        if(ListInsert(&ev, event, compare)<0){
            LOG("error:fail insert (%d,%d) to evenlist", event.OccurTime, event.NType);
            return -1;
        }
    }
    return 0;
}

int main(int argc, char *argv[]){
    LOG("利用队列实现银行业务模拟! 营业时间0 - %d", CloseTime);
    int timer = 0;
    if(OpenForDay()<0){
        return -1;
    }
    while(!ListEmpty(ev)){
        timer += 1;
        if(ListDelete(&ev,0,&en)<0){
            LOG("error:delete event from list error!");
            break;
        }
        if(en.NType == 0){
            if(CustomerArrived()<0){
                LOG("error:handle new customer fail!");
                break;
            }
        }else{
            if(CustomerDeparture()<0){
                LOG("error:handle leave customer fail!");
                break;
            }
        }
//        if(timer % 20){
            LOG("TotalTime=%d, CustomerNum=%d, timer=%d", TotalTime, CustomerNum, timer);
            LOG("窗口 1");
            TraverseQueue(q[1]);
            LOG("窗口 2");
            TraverseQueue(q[2]);
            LOG("窗口 3");
            TraverseQueue(q[3]);
            LOG("窗口 4");
            TraverseQueue(q[4]);
            LOG("事件表");
            ListTraverse(ev);
            LOG("");
//        }

    }
    LOG("The Average Time is %f", (float)TotalTime/CustomerNum);
    return 0;
}




/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
static int InitQueue(SqQueue *Q)
{
    Q->base = (QElemType *)malloc(MAXQSIZE * sizeof(QElemType));
    if(Q->base == NULL){
        return -1;
    }
    Q->front = 0;
    Q->rear = 0;
    return 0;
}

static int QueueLength(SqQueue Q){
    return (Q.rear-Q.front+MAXQSIZE) % MAXQSIZE;
}

static int EnQueue(SqQueue *Q, QElemType e){
    if((Q->rear+1+MAXQSIZE)%MAXQSIZE == Q->front){
        LOG("error: queue full!");
        return -1;
    }else{
        Q->base[Q->rear] = e;
        Q->rear = (Q->rear+1+ MAXQSIZE)%MAXQSIZE;
        return 0;
    }
}

static int DeQueue(SqQueue *Q, QElemType *e){
    if(Q->front == Q->rear){
        LOG("error: queue emopty!");
        return -1;
    }else{
        *e = Q->base[Q->front];
        Q->front = (Q->front + 1 + MAXQSIZE) % MAXQSIZE;
        return 0;
    }
}

static int TraverseQueue(SqQueue Q){
    int i = Q.front;
    do{
        if(i == Q.rear){
            break;
        }
        i = (i+1+MAXQSIZE) % MAXQSIZE;
    }while(1);
    return 0;
}
//return 0:not empty; -1 empty
static int QueueEmpty(SqQueue Q){
    if(Q.front == Q.rear){
        return -1;
    }else{
        return 0;
    }
}

static int GetQueueHead(SqQueue Q, QElemType *e)
{
    if(QueueEmpty(Q)){
        return -1;
    }
    (*e) = Q.base[Q.front];
    return 0;
}



/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
static int InitList(LinkList *L){
    if(L==NULL){
        return -1;
    }
    if((L->elem=(ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType))) == NULL){
        return -1;
    }
    L->length = 0;
    L->listsize = LIST_INIT_SIZE;
    return 0;
}

static int ListInsert(LinkList *L, ElemType e, int (*fun)(ElemType e1, ElemType e2)){
    int i = 0;
    int j = 0;
    if(L->length == L->listsize){
        //kuo rong
        ElemType *newbase = NULL;
        if((newbase=(ElemType*)realloc(L->elem, (L->listsize+LIST_INCREMENT)* sizeof(ElemType))) == NULL){
            return -1;
        }
        L->elem = newbase;
        L->listsize += LIST_INCREMENT;
    }
    for(i=0; i<L->length; i++){
        if(fun(e, L->elem[i])<0){
            break;
        }
    }
    for(j=L->length; j>=i; j--){
        L->elem[j+1] = L->elem[j];
    }
    L->elem[i] = e;
    L->length += 1;
    return 0;
}

static int ListDelete(LinkList *L, int locate, ElemType *e){
    if(locate<0 || locate>(L->length-1) || L->length<1){
        return -1;
    }
    (*e) = L->elem[locate];
    int i = 0;
    for(i=locate+1; i<L->length; i++){
        L->elem[i-1] = L->elem[i];
    }
    L->length -= 1;
    return 0;
}

static int compare(ElemType e1, ElemType e2){
    if(e1.OccurTime < e2.OccurTime){
        return -1;
    }else if(e1.OccurTime == e2.OccurTime){
        return 0;
    }else{
        return 1;
    }
}

static int ListTraverse(LinkList L){
    int i = 0;
    for(i=0; i<L.length; i++){
        LOG("序号%d=(发生时间%d, 事件类型%d)", i, L.elem[i].OccurTime, L.elem[i].NType);
    }
}

//return 0:not empty;  -1:empty
static int ListEmpty(LinkList L){
    if(L.length>0){
        return 0;
    }else{
        return -1;
    }
}

代码运行

/home/lady/CLionProjects/untitled/cmake-build-debug/untitled
利用队列实现银行业务模拟! 营业时间0 - 50
TotalTime=0, CustomerNum=1, timer=1
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间4, 事件类型0)
序号1=(发生时间17, 事件类型1)

TotalTime=0, CustomerNum=2, timer=2
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间8, 事件类型0)
序号1=(发生时间17, 事件类型1)
序号2=(发生时间21, 事件类型2)

TotalTime=0, CustomerNum=3, timer=3
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间12, 事件类型0)
序号1=(发生时间17, 事件类型1)
序号2=(发生时间21, 事件类型2)
序号3=(发生时间25, 事件类型3)

TotalTime=0, CustomerNum=4, timer=4
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间16, 事件类型0)
序号1=(发生时间17, 事件类型1)
序号2=(发生时间21, 事件类型2)
序号3=(发生时间25, 事件类型3)
序号4=(发生时间29, 事件类型4)

TotalTime=0, CustomerNum=5, timer=5
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间17, 事件类型1)
序号1=(发生时间20, 事件类型0)
序号2=(发生时间21, 事件类型2)
序号3=(发生时间25, 事件类型3)
序号4=(发生时间29, 事件类型4)

TotalTime=17, CustomerNum=5, timer=6
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间20, 事件类型0)
序号1=(发生时间21, 事件类型2)
序号2=(发生时间25, 事件类型3)
序号3=(发生时间29, 事件类型4)
序号4=(发生时间34, 事件类型1)

TotalTime=17, CustomerNum=6, timer=7
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间21, 事件类型2)
序号1=(发生时间24, 事件类型0)
序号2=(发生时间25, 事件类型3)
序号3=(发生时间29, 事件类型4)
序号4=(发生时间34, 事件类型1)

TotalTime=34, CustomerNum=6, timer=8
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间24, 事件类型0)
序号1=(发生时间25, 事件类型3)
序号2=(发生时间29, 事件类型4)
序号3=(发生时间34, 事件类型1)

TotalTime=34, CustomerNum=7, timer=9
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间25, 事件类型3)
序号1=(发生时间28, 事件类型0)
序号2=(发生时间29, 事件类型4)
序号3=(发生时间34, 事件类型1)
序号4=(发生时间41, 事件类型2)

TotalTime=51, CustomerNum=7, timer=10
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间28, 事件类型0)
序号1=(发生时间29, 事件类型4)
序号2=(发生时间34, 事件类型1)
序号3=(发生时间41, 事件类型2)

TotalTime=51, CustomerNum=8, timer=11
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间29, 事件类型4)
序号1=(发生时间32, 事件类型0)
序号2=(发生时间34, 事件类型1)
序号3=(发生时间41, 事件类型2)
序号4=(发生时间45, 事件类型3)

TotalTime=68, CustomerNum=8, timer=12
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间32, 事件类型0)
序号1=(发生时间34, 事件类型1)
序号2=(发生时间41, 事件类型2)
序号3=(发生时间45, 事件类型3)

TotalTime=68, CustomerNum=9, timer=13
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间34, 事件类型1)
序号1=(发生时间36, 事件类型0)
序号2=(发生时间41, 事件类型2)
序号3=(发生时间45, 事件类型3)
序号4=(发生时间49, 事件类型4)

TotalTime=86, CustomerNum=9, timer=14
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间36, 事件类型0)
序号1=(发生时间41, 事件类型2)
序号2=(发生时间45, 事件类型3)
序号3=(发生时间49, 事件类型4)
序号4=(发生时间51, 事件类型1)

TotalTime=86, CustomerNum=10, timer=15
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间40, 事件类型0)
序号1=(发生时间41, 事件类型2)
序号2=(发生时间45, 事件类型3)
序号3=(发生时间49, 事件类型4)
序号4=(发生时间51, 事件类型1)

TotalTime=86, CustomerNum=11, timer=16
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间41, 事件类型2)
序号1=(发生时间44, 事件类型0)
序号2=(发生时间45, 事件类型3)
序号3=(发生时间49, 事件类型4)
序号4=(发生时间51, 事件类型1)

TotalTime=103, CustomerNum=11, timer=17
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间44, 事件类型0)
序号1=(发生时间45, 事件类型3)
序号2=(发生时间49, 事件类型4)
序号3=(发生时间51, 事件类型1)
序号4=(发生时间58, 事件类型2)

TotalTime=103, CustomerNum=12, timer=18
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间45, 事件类型3)
序号1=(发生时间48, 事件类型0)
序号2=(发生时间49, 事件类型4)
序号3=(发生时间51, 事件类型1)
序号4=(发生时间58, 事件类型2)

TotalTime=120, CustomerNum=12, timer=19
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间48, 事件类型0)
序号1=(发生时间49, 事件类型4)
序号2=(发生时间51, 事件类型1)
序号3=(发生时间58, 事件类型2)

TotalTime=120, CustomerNum=13, timer=20
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间49, 事件类型4)
序号1=(发生时间51, 事件类型1)
序号2=(发生时间58, 事件类型2)
序号3=(发生时间65, 事件类型3)

TotalTime=137, CustomerNum=13, timer=21
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间51, 事件类型1)
序号1=(发生时间58, 事件类型2)
序号2=(发生时间65, 事件类型3)

TotalTime=168, CustomerNum=13, timer=22
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间58, 事件类型2)
序号1=(发生时间65, 事件类型3)
序号2=(发生时间68, 事件类型1)

TotalTime=186, CustomerNum=13, timer=23
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间65, 事件类型3)
序号1=(发生时间68, 事件类型1)
序号2=(发生时间75, 事件类型2)

TotalTime=203, CustomerNum=13, timer=24
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间68, 事件类型1)
序号1=(发生时间75, 事件类型2)

TotalTime=235, CustomerNum=13, timer=25
窗口 1
窗口 2
窗口 3
窗口 4
事件表
序号0=(发生时间75, 事件类型2)

TotalTime=266, CustomerNum=13, timer=26
窗口 1
窗口 2
窗口 3
窗口 4
事件表

The Average Time is 20.461538

Process finished with exit code 0