队列（循环、链式）

//–––––循环队列──队列的顺序存储结构–––––
#define MAXQSIZE   100                 //最大队列长度
typedef  struct
{
    ElemType* base;        //初始化的动态分配存储空间

    int front;                //头指针,若队列不空,指向队列头元素

    int rear;   //尾指针,若队列不空,指向队列尾元素的下一个位置
}SqQueue;
Status InitQueue(SqQueue& Q)
{//  构造一个空队列Q
    Q.base =(ElemType*)malloc(sizeof(ElemType) * MAXQSIZE);
    if (!Q.base)  exit(OVERFLOW);  //存储分配失败
    Q.front = 0;
    Q.rear = Q.front ;
    return OK;
}
int QueueLength(SqQueue Q)
{//返回Q的元素个数,即队列的长度
    return(Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}
Status EnQueue(SqQueue& Q, QElemType e)
{// 插入元素e为Q的新的队尾元素
    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)
{// 删除队头元素，送给变量e
    if (Q.front == Q.rear) return ERROR;   //队列空
    e =Q.base[Q.front];

    Q.front = (Q.front + 1) % MAXQSIZE;
    return OK;
}
Status QueueEmpty(SqQueue Q)
{
    if ((Q.rear + 1) % MAXSIZE == Q.front) return TRUE;
    return FALSE;
}

typedef  int  Status;
typedef char QElemType;

//–––––队列的链式存储结构–––––
typedef  struct QNode
{
    QElemType     data;
    struct QNode* next;
}QNode, * QueuePtr;

typedef struct
{
    QueuePtr
        front;      //队头指针

    QueuePtr
        rear;        //队尾指针
}LinkQueue;

Status InitQueue(LinkQueue& Q)
{// 构造一个空队列Q
    Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
        
    if (!Q.front) exit(OVERFLOW);     //存储分配失败

    Q.rear->next = NULL;
        
    return OK;
}

Status DestroyQueue(LinkQueue& Q)
{// 销毁队列Q
    while (Q.front)
    {
        Q.rear = Q.front->next;

        free(Q.front);
        Q.front =Q.rear;
    }
    return OK;
}

int QueueLength(LinkQueue Q)
{//返回Q的元素个数,即队列的长度
    QueuePtr p;
    int len = 0;
    p = Q.front;
    while (p != Q.rear)
    {
        len++;

        p = p->next;
    }
    return len;
}
Status EnQueue(LinkQueue& Q, QElemType e)
{// 插入元素e为Q的新的队尾元素
    QueuePtr p;
    p = (QueuePtr)malloc(sizeof(QNode));
    if (!p)  exit(OVERFLOW);        //存储分配失败
    p->data = e;   p->next = NULL;

    Q.rear->next = p;
    Q.rear =p->next;
    return OK;
}

Status DeQueue(LinkQueue& Q, QElemType& e)
{//若队列不空,则删除Q的队头元素,用e返回其值,
//并返回OK;  否则返回ERROR
    QueuePtr p;
    if (Q.front == Q.rear) 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;
}

Status QueueEmpty(LinkQueue Q)
{
    if (Q.front == Q.rear) return TRUE;
    return FALSE;
}