银行模拟：队列的应用，软件方法应用

#include <cstdlib>
#include <ctime>
#include <cstdio>

enum EventType{ENTER,LEAVE};

struct Event{
    EventType type;
    int startTime;
    int queNum;
};

class EventList{
public:
    EventList(){
        list = NULL;
        size = 0;
    }

    ~EventList(){
        struct EventNode *q,*p;
        q = p = list;
        while(p){
            q = p;
            p = p->next;
            delete q;
        }
    }

    bool isEmpty(){
        return list == NULL;
    }

    void pushEvent(struct Event &e){
        struct EventNode *node = new struct EventNode;
        node->e = e;
        node->next = NULL;
        struct EventNode *p,*q;
        p = q = list;
        if(!p){
            list = node;
        }else{
            while(p){
                if(p->e.startTime < e.startTime){
                    q = p;
                    p = p->next;
                }else{
                    break;
                }
            }
            if(p == q){
                node->next = list;
                list = node;
            }else{
                node->next = p;
                q->next = node;
            }
        }
        size++;
    }

   int popEvent(struct Event &e){
        if(!list)
            return -1;
        e.type = list->e.type;
        e.startTime = list->e.startTime;
        e.queNum = list->e.queNum;
        struct EventNode *tmp = list;
        list = list->next;
        delete tmp;
        size--;
        return 0;
    }

    bool hasEvents(){
        return size > 0;
    }

    int getSize(){
        return size;
    }

    void print(){
        struct EventNode *p = list;
        printf("event size:%d\n",size);
        while(p){
            printf("event(%s,%d,%d)\n",p->e.type == ENTER ? "enter":"leave",p->e.startTime,p->e.queNum);
            p = p->next;
        }
    }
    void myDebug(){
        struct Event e = {ENTER,10,-1};;
        for(int i = 0; i < 5; i++){
            pushEvent(e);
        }
        print();
        for(int i = 0; i < 5;i++){
            popEvent(e);
        }
        printf("is Empty:%d\n",isEmpty());
    }
private:
    struct EventNode{
        struct Event e;
        struct EventNode *next;
        };
    struct EventNode *list;
    int size;
};

struct customer{
    int duration;
    int enterTime;
};

class Queue{
public:
    Queue(){
        head = end = NULL;
        size = 0;
    }

    ~Queue(){
        struct CustomerNode *p,*q;
        p = q = head;
        while(p){
            q = p;
            p = p->next;
            delete q;
        }
    }

    void enque(struct customer &c){
        struct CustomerNode *tmp = new struct CustomerNode;
        tmp->c = c;
        tmp->next = NULL;
        if(isEmpty()){
            head = end = tmp;
        }else{
            end->next = tmp;
            end = tmp;
        }
        size++;
    }

    void deque(struct customer &c){
        if(isEmpty())
            return;
        if(head == end){
            c = head->c;
            delete head;
            head = end = NULL;
        }else{
            c = head->c;
            struct CustomerNode *tmp = head;
            head = head->next;
            delete tmp;
        }
        size--;
    }

    const struct customer* getHead(){
        return &(head->c);
    }

    bool isEmpty(){
        return head == NULL;
    }

    int getSize(){
        return size;
    }
    void print(){
        struct CustomerNode *p = head;
        printf("mysize:%d\n",getSize());
        while(p){
            printf("customer:(enterTime:%d,durationTime:%d)\n\n",p->c.enterTime,p->c.duration);
            p = p->next;
        }
    }
    void myDebug(){
        print();
        struct customer c = {10,30};
        for(int i = 0; i < 5; i++){
            enque(c);
        }
        print();
        for(int i = 0; i < 5; i++){
            deque(c);
        }
        print();
    }
private:
    int size;
    struct CustomerNode{
        struct customer c;
        struct CustomerNode *next;
    };
    struct CustomerNode *head,*end;
};

#define QNUM 4
#define MAX_DURATION_TIME 31
#define MAX_NEXT_CUSTOMER_TIME 6
EventList *evlist;
struct Event ev;
Queue *que[QNUM];
int currentTime,totalTime,count;
int closeTime;
int leftcount;
int totalDuration;

void bankOpen(){
    leftcount = 0;
    closeTime = 200;
    currentTime = totalTime = count = totalDuration = 0;
    evlist = new EventList;
    for(int i = 0; i < QNUM; i++)
        que[i] = new Queue;
    srand(time(NULL));
    struct Event e;
    e.startTime = currentTime + rand() % MAX_NEXT_CUSTOMER_TIME;
    e.type = ENTER;
    e.queNum = -1;
    evlist->pushEvent(e);
}
void bankClose(){
    delete evlist;
    for(int i = 0; i < QNUM; i++)
        delete que[i];
}
int findMinQue(){
    int q = 0;
    int size = que[0]->getSize();
    for(int i = 1; i < QNUM; i++){
        if(que[i]->getSize() < size)
        {
            size = que[i]->getSize();
            q = i;
        }
    }
    return q;
}

void makeCustomer(struct customer &c){
    c.duration = rand() % MAX_DURATION_TIME;
    c.enterTime = ev.startTime;
}

void customerEnter(){
    if(currentTime > closeTime)
        return ;
    /*deal with current enter event */
    struct customer newcustomer;
    makeCustomer(newcustomer);
    totalDuration += newcustomer.duration;
    int q = findMinQue();
    que[q]->enque(newcustomer);
    if(que[q]->getSize() == 1){
        struct Event e;
        e.type = LEAVE;
        e.queNum = q;
        e.startTime = currentTime + newcustomer.duration;
        evlist->pushEvent(e);
    }
    printf("que[%d]:\n",q);
    que[q]->print();
    /*make a new enter event*/
    struct Event e;
    e.type = ENTER;
    e.queNum = -1;
    e.startTime = currentTime + rand() % MAX_NEXT_CUSTOMER_TIME;
    evlist->pushEvent(e);
}

void customerLeave(){
    /*accumulate time*/
    struct customer c;
    que[ev.queNum]->deque(c);
    totalTime += ev.startTime - c.enterTime;
    count++;
    /*add a leave event*/
    if(!que[ev.queNum]->isEmpty()){
        struct Event e;
        e.type = LEAVE;
        e.queNum = ev.queNum;
        const struct customer *top = que[ev.queNum]->getHead();
        e.startTime = currentTime + top->duration;
        evlist->pushEvent(e);
    }
}

void myDebug()
{
    printf("currentTime:%d\n",currentTime);
    printf("totalTime:%d\n",totalTime);
    printf("count:%d\n",count);
    printf("leftcount:%d\n",leftcount);
    evlist->print();
    printf("quesize:%d,%d,%d,%d\n\n",
                que[0]->getSize(),
                que[1]->getSize(),
                que[2]->getSize(),
                que[3]->getSize()
           );
}

void bank(){
    bankOpen();
    while(evlist->hasEvents()){
        myDebug();
        evlist->popEvent(ev);
        currentTime = ev.startTime;
//        getchar();
        if(ev.type == ENTER){
            leftcount++;
            customerEnter();
        }else{
            leftcount--;
            customerLeave();
        }
    }
    bankClose();
    printf("averageDurationTime:%d,averageWaitTime:%d \n",totalDuration/count,totalTime/count);
}

int main(void){
    bank();
    return 0;
}