[데이터 구조] 분 산 된 사건 시 뮬 레이 션

27061 단어 데이터 구조
#include "book3_6.h"

//

#define CloseTime 600

EventList ev; //   

Event     en; //  

LinkQueue  q[5]; //4     

QElemType customer; //    

int TotalTime,CustomerNum; //



int Minimum(LinkQueue q[])

{

    int l[5];

    for (int i=1; i<=4; i++)

    {

        l[i]=q[i].rear - q[i].front;

    }

    int a = l[1]>l[2]?2:1;

    int b = l[3]>l[4]?4:3;

    return l[a]>l[b]?b:a;

}



void OpenForDay()

{

    //     

    TotalTime = 0; CustomerNum = 0; //           

    ListCreate_L(ev);               //          

    en.OccurTime = 0; en.NType = 0; //           

    OrderInsert(ev,en,cmp);         //     

    for(int i=1;i<=4;i++) InitQueue_L(q[i]); //    

}//OpenForDay



void CustomerArrived()

{

    //          en.NType = 0;

    

    int durtime, intertime;

    ElemType tmp;

    QElemType Qtmp;

    ++CustomerNum;

    

    durtime = 1+(int)(30.0*rand()/(RAND_MAX+1.0)); //    

    intertime = 1+(int)(5.0*rand()/(RAND_MAX+1.0)); //          

    //printf("durtime:%d\ intertime:%d
",durtime,intertime);
int t = en.OccurTime + intertime; // if(t<CloseTime) // { tmp.OccurTime = t; tmp.NType = 0; OrderInsert(ev,tmp,cmp); } int i = Minimum(q); Qtmp.ArrivalTime = en.OccurTime; Qtmp.Duration = durtime; EnQueue_L(q[i],Qtmp); // if(QueueLength_L(q[i]) == 1) { tmp.OccurTime = en.OccurTime+durtime; tmp.NType = i; OrderInsert(ev,tmp,cmp); // 1 } } void CustomerDeparture() { // ,en.Type>0; ElemType tmp; int i = en.NType; DeQueue_L(q[i],customer); // i //printf("time:%d
",en.OccurTime - customer.ArrivalTime);
TotalTime += en.OccurTime - customer.ArrivalTime; if(!QueueEmpty_L(q[i])) { GetHeadQueue_L(q[i],customer); tmp.NType = i; tmp.OccurTime = en.OccurTime + customer.Duration; OrderInsert(ev,(tmp),cmp); } } void Bank_Simulation() { ElemType tmp; OpenForDay(); while(!ListEmpty_L(ev)) { ListDeleteFirst_L(ev, tmp); en = tmp; if(en.NType == 0) CustomerArrived(); else CustomerDeparture(); } printf("The Average Time is %f
",(float)TotalTime/CustomerNum); } void main() { srand((int)time(0)); for(int i=0; i<10; i++) { Bank_Simulation(); } getchar(); }
#include<stdio.h>

#include<stdlib.h>

#include<time.h> 





typedef int Status;

const int TRUE=1;

const int FALSE=0;

const int OK=1;

const int ERROR=0;

const int INFEASIBLE=-1;

const int overflow=-2;

const int STACK_INIT_SIZE=100;

const int STACKINCREMENT=10;





typedef struct{

    int ArrivalTime;

    int Duration;

}QElemType;





//    

typedef struct{

    int OccurTime;

    int NType;

}Event, ElemType; //    



typedef struct LNode{

    ElemType data; 

    struct LNode *next;

}LNode, *LinkList;    //      



typedef LinkList EventList; 



int cmp(int a , int b)

{

    if(a>b)

        return 1;

    else if(a<b)

        return -1;

    else 

        return 0;

}







// OccurTime                     

Status OrderInsert( LinkList &L, ElemType e, int(* compare)(int, int))

{

    ElemType tmp;

    LinkList s;

    LinkList p = L;

    if(p->next==NULL)  //         

    {

        s = (LinkList)malloc(sizeof(LNode)); 

        s->data = e; s->next = p->next;

        p->next = s;

    }

    else

    {

            while(compare(e.OccurTime,p->next->data.OccurTime) != -1)

            {    

                p = p->next;

                if(p->next == NULL)

                {

                    s = (LinkList)malloc(sizeof(LNode)); 

                    s->data = e; s->next = p->next;

                    p->next = s;

                    return OK;

                }

            }

            s = (LinkList)malloc(sizeof(LNode));

            s->data = e; s->next = p->next;

            p->next = s;

    

        

    }



    return OK;



}



//           

Status ListDeleteLast_L(LinkList &L, ElemType &e)

{

    LinkList s;

    LinkList p = L;

    while(p->next->next != NULL)

    {

        p = p->next;

    }

    s = p;

    e = p->next->data;

    free(p->next);

    s->next = NULL;



    return OK;

}



//         

Status ListCreate_L(LinkList &L)

{

    if(L == NULL)

    {

        L = (LinkList)malloc(sizeof(LNode));

        L->next = NULL;

        return OK;

    }

    else

        return ERROR;

}



//      

Status ListDestroy_L(LinkList &L)

{

    LinkList p=L, s;

    while(p->next != NULL)

    {

        s = p; p = p->next;  free(s);

    }

    return OK;

}



bool ListEmpty_L(LinkList L)

{

    if(L->next==NULL)

        return true;

    else

        return false;

}



//          

Status ListDeleteFirst_L(LinkList &L, ElemType &e)

{

    LinkList s;

    LinkList p = L;



    s = p;

    p = p->next;

    e = p->data;

    s->next = p->next;

    free(p);



    return OK;

}















//    

#define MAXQSIZE 100

typedef struct{

    QElemType *base;

    int front;

    int rear;

}SqQueue;



Status InitQueue(SqQueue &Q)

{

    //       Q

    Q.base = (QElemType * ) malloc (MAXQSIZE * sizeof(QElemType));

    if(!Q.base) exit(overflow);

    Q.front = Q.rear = 0;

    return OK;

}



int QueueLength(SqQueue Q)

{

    //  Q     ,      

    return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;

}



Status EnQueue(SqQueue &Q, QElemType e)

{

    //    e       

    if((Q.rear +1)%MAXQSIZE == Q.front) return ERROR; //   

    Q.base[Q.rear] = e;

    Q.rear = (Q.rear +1) % MAXQSIZE;

    return OK;

}



Status DeQueue(SqQueue &Q, QElemType &e)

{

    //     ,   Q     ,  e    ,   OK;

    //     ERROR

    if(Q.front == Q.rear) return ERROR;

    e = Q.base[Q.front];

    Q.front = (Q.front + 1)%MAXQSIZE;

    return OK;

}



Status DestroyQueue(SqQueue &Q)

{

    //    Q

    if(Q.base != NULL)

    {

        free(Q.base);

        Q.front = Q.rear =0;

        return OK;

    }

    return ERROR;

}



Status GetHeadQueue(SqQueue &Q, QElemType &e)

{

    //         

    e = Q.base[Q.front];

    return OK;

}





//   

typedef struct QNode{

    QElemType data;

    struct QNode *next;

}QNode, *QueuePtr;



typedef struct{

    QueuePtr front; //    

    QueuePtr rear;  //    

}LinkQueue;



Status InitQueue_L(LinkQueue &Q)

{

    //       Q

    Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));

    if(Q.front==NULL) exit(overflow);

    Q.front->next=NULL;

    return OK;

}



Status DestroyQueue_L(LinkQueue &Q)

{

    //      

    while(Q.front!=NULL)

    {

        Q.rear = Q.front->next;

        free(Q.front);

        Q.front = Q.rear;

    }

    return OK;

}



Status EnQueue_L(LinkQueue &Q, QElemType e){

    //    e Q       

    QueuePtr p = (QueuePtr)malloc(sizeof(QNode));

    if(!p) exit(overflow);

    p->data = e;  p->next =NULL;

    Q.rear->next = p;

    Q.rear  = p;

    return OK;

}



Status DeQueue_L(LinkQueue &Q, QElemType &e)

{

    //        Q     , e    ,   OK

    //    ERROR

    QueuePtr p;

    if(Q.rear == Q.front) return ERROR;

    p = Q.front->next;

    e = p->data;

    Q.front->next = p->next;

    if(Q.rear == p) Q.rear = Q.front;

    free(p);

    return OK;

}



int QueueLength_L(LinkQueue Q)

{

    //  Q     ,      

    if(Q.front == Q.rear)

    {

        return 0;

    }

    QueuePtr p = Q.front;

    int i = 1;

    while(p->next != Q.rear)

    {

        i++;

        p=p->next;

    }

    return i;

}



bool QueueEmpty_L(LinkQueue Q)

{

    if(Q.rear == Q.front)

        return true;

    else

        return false;

}



Status GetHeadQueue_L(LinkQueue Q, QElemType &e)

{

    e = Q.front->next->data;

    return OK;

}

주 프로그램 과 헤더 파일 이 위 와 같 습 니 다.
주의:
1. srand () 는 한 번 만 초기 화 합 니 다. 그렇지 않 으 면 같은 난수 가 발생 합 니 다.
2. 모 의 과정 은 일상생활 에 부합 되 어야 한다. 즉, 한 고객 이 올 때 다음 고객 이 오 는 사건 이 발생 하고 팀 의 고객 이 떠 날 때 새로운 팀 의 고객 이 떠 나 는 사건 이 발생 한다. 원래 대열 에 새로 가입 하 는 사람 이 없 을 때 고객 이 떠 나 는 사건 이 발생 한다.모든 고객 이 기다 리 는 시간 을 계산 하 는 것 은 사건 을 떠 나 는 시간 을 통 해 도착 하 는 시간 을 빼 는 것 이지 자신 이 추가 한 것 이 아니다.

좋은 웹페이지 즐겨찾기