j++;
    }
    if(p==L)
        return ERROR;
    *e = p->data;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    free(p);
    return OK;
}

void print(DuLinkList L)
{
    DuLNode *p;
    p = L->next;
    while(p!=L)
    {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
}

void main()
{
    int i;
    ElemType e;
    DuLinkList L;
    if(!(L=(DuLNode *)malloc(sizeof(DuLNode))))
        exit(0);
    L->next = L;
    L->prior = L;
    for(i=1;i<10;i++)
    {
        e = (ElemType)i;
        if(!(ListInsert_DuL(L,i,e)))
            printf("No.%d is wrong!\n",i);
    }
    print(L);
    ListInsert_DuL(L,5,(ElemType)10);
    print(L);
    ListDelete_DuL(L,1,&e);
    print(L);
    printf("please input a number:");
    scanf("%d",&i);
    if(GetElem_DuL(L,i,&e))
        printf("L[%d]=%d\n",i,e);
    else
        printf("%d is illegal!\n",i);
}

7、编制一个程序以模拟银行窗口接待客户的排队业务活动（每个窗口在某个时刻只能接待
一个客户；窗口空闲，则可上前办理业务；窗口均被占，则新客户便会排在人数最少的队伍
前面），并计算一天中客户在银行逗留的平均时间。（本题20分）

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAX 10000
#define OK 1
#define ERROR 0
/**********数据类型定义(Start)**********/
typedef int Status;

typedef struct
{
    int OccurTime;             //事件发生时刻
    int NType;                 //事件类型，0~5
}Event,ElemType;               //事件类型，有序链表LinkList的数据元素类型

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

typedef LinkList EventList;    //事件链表类型，定义为有序链表

typedef struct
{
    int ArrivalTime;           //到达时间
    int Duration;              //办理事务所需时间
}QElemType;                    //队列的数据元素类型

typedef struct QNode
{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;

typedef struct
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

/**********数据类型定义(Over)**********/

/**********程序中用到的主要变量(Start)**********/
EventList ev;                  //事件表
Event en;                      //事件
LinkQueue q[5];                //4个客户队列
QElemType customer;            //客户记录
long TotalTime,CustomerNum;     //累计客户逗留时间，客户数
/**********程序中用到的主要变量(Over)**********/

/**********自定义函数部分(Start)**********/
/****链表操作部分(start)****/
int cmp(ElemType a,ElemType b)
{
    if(a.OccurTime>b.OccurTime)
        return 1;
    else if(a.OccurTime==b.OccurTime)
        return 0;
    else
        return -1;
}

void InitList(LinkList &L)
{
    L = (LNode *)malloc(sizeof(LNode));
    if(!L)
        printf("EVENTLIST INIT ERROR!\n");
    else
    {
        L->next = NULL;
    }
}

void OrderInsert(LinkList L,ElemType en)
{
    LNode *p,*q,*s;
    p = L;
    q = p->next;
    while(q && (cmp(q->data,en)==-1))
    {
        p = q;
        q = p->next;
    }
    s = (LNode *)malloc(sizeof(LNode));
    s->data.OccurTime = en.OccurTime;
    s->data.NType = en.NType;
    p->next = s;
    s->next = q;
}

int ListEmpty(LinkList L)
{
    if(L->next!=NULL)
        return 0;
    else
        return 1;
}

void DelFirst(LinkList L,ElemType *e)
{
    LNode *p;
    p = L->next;
    L->next = p->next;
    e->OccurTime = p->data.OccurTime;
    e->NType = p->data.NType;
    free(p);
}

/****链表操作部分(over)****/

/****队列操作部分(start)****/
void InitQueue(LinkQueue *Q)
{
    Q->front = Q->rear = (QNode *)malloc(sizeof(QNode));
    if(!(Q->front))
        printf("LinkQueue INIT ERROR!\n");
    Q->front->next = NULL;
}




Status DelQueue(LinkQueue *Q,QElemType *e)
{
    QNode *p;
    if(Q->front==Q->rear) return ERROR;
    p = Q->front->next;
    e->ArrivalTime = p->data.ArrivalTime;
    e->Duration = p->data.Duration;
    Q->front->next = p->next;
    if(Q->rear == p) Q->rear = Q->front;
    free(p);
    return OK;
}


Status EnQueue(LinkQueue *Q,QElemType e)
{
    QNode *p;
    p = (QNode *)malloc(sizeof(QNode));
    if(!p) exit(0);
    p->data.ArrivalTime = e.ArrivalTime;
    p->data.Duration = e.Duration;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
    return OK;

}

int QueueLength(LinkQueue *Q)
{
    int i=0;
    QNode *p;
    if(Q->front==Q->rear)   i = 0;
    else
    {
        p = Q->front;
        while(p!=Q->rear)
        {
            p = p->next;
            i++;
        }
    }
    return i;
}
/****队列操作部分(over)****/

/****业务操作部分(start)****/
void Random(long *durtime,long *intertime)
{
    srand(time(NULL));
    *durtime = rand();
    *intertime = rand();
}

int Minimum(LinkQueue q[])
{
    int i,j,k=0,min = MAX;
    QNode *p;
    for(i=1;i<=4;i++)
    {
        if(q[i].front == q[i].rear)