#include?
#include?
#include??

#define?ARRIVE?0
#define?DEPAR?1
#define?IDLE???0
#define?OCCUPY?1

int?queueMaxqueueLength=0custNumcustNumQueue=0busy=IDLE;?
double?clock=0sumDelay=0sumServe=0;


typedef?struct?eventNode{
	int?typeid;
	double?arriveTime;
	double?serveTime;
	double?deparTime;
	
	struct?eventNode*?nextlink;?
}event;
event*?queueTail;

struct?eventHeadNode{
	struct?eventNode*?eventlink?;
};
struct?eventHeadNode*?eventHead;


struct?queueHeadNode{
	struct?eventNode*?queuelink;
};
struct?queueHeadNode*?queueHead;

double?U_Random（）;
double?possion（int?lambdaArrive）;
double?exponential（double?lambdaServe）;
void?initialFEL（int?lambdaArrivedouble?lambdaServe）;
void?serve（）;
void?placeEvent（event*?eventTemp）;
void?addQueue（event*?eventTemp）;
void?destroyEventHead（event*?eventTemp）;
event*?popQueue（）;
void?bl（）;

double?U_Random（）??
{
??double?f;
??f?=?（float）（rand（）?%?100）;
?
??return?f/100;
}


double?possion（int?lambdaArrive）{
	int?k=0;
	long?double?p=1.0;
	long?double?l=exp（-lambdaArrive）;
	
	
	while（p>=l）{
		double?u?=?U_Random（）;
		p*=u;
		k++;
	}
	return?k-1;
}

double?exponential（double?lambdaServe）{
	double?u;
	
	do{
		u=（double）（rand（）%100）/100;
	}while（u==0）;
	u=（-1/lambdaServe）*log（u）;
	return?u;
}

void?initialFEL（int?lambdaArrivedouble?lambdaServe）{
	int?i;
	double?sumTime=0;
	event*?eventCur;

	for（i=0;i		if（eventHead->eventlink==NULL）{
			eventCur=（event*）malloc（sizeof（event））;
			eventCur->type=ARRIVE;
			eventCur->arriveTime=possion（lambdaArrive）;
			eventCur->serveTime=exponential（lambdaServe）;
			eventCur->deparTime=-1;
			eventCur->nextlink=NULL;
			eventCur->id=i;
			eventHead->eventlink=eventCur;
			sumTime=eventCur->arriveTime;
		}
		else{
			eventCur->nextlink=（event*）malloc（sizeof（event））;
			eventCur=eventCur->nextlink;
			eventCur->type=ARRIVE;
			sumTime+=possion（lambdaArrive）;
			eventCur->arriveTime=sumTime;
			eventCur->serveTime=exponential（lambdaServe）;
			eventCur->deparTime=-1;
			
			eventCur->nextlink=NULL;
			eventCur->id=i;
		}
		printf（“%d號顧客到達時間：%lf，服務時間：%lf\n“eventCur->ideventCur->arriveTimeeventCur->serveTime）;
	}	
	
}

void?serve（）{
	event*?eventCur;
	while（eventHead->eventlink!=NULL）{
		eventCur=eventHead->eventlink;
		
		if（eventCur->type==ARRIVE）{
			clock=eventCur->arriveTime;
		
			if（busy==IDLE）{
				busy=OCCUPY;
				eventCur->deparTime=clock+eventCur->serveTime;
				eventCur->type=DEPAR;
				
				destroyEventHead（eventCur）;
				placeEvent（eventCur）;
			}
			else{
				if（queueLength					destroyEventHead（eventCur）;
					addQueue（eventCur）;
					?
					custNumQueue++;
					queueLength++;
				}
				else{
					destroyEventHead（eventCur）;
					free（eventCur）;
				}
			}
		}