3.3 数据结构——队列

3.3.1 队列的定义

        队列（Queue）是只允许在表尾进行插入操作，在表头进行删除操作的线性表；同时队列也是先进先出（First In First Out）的线性表，简称FIFO。插入元素称为入队，删除元素称为出队。假设又这么一个队列：，那么就是队头元素，就是队尾元素。

 3.3.2 队列的抽象数据类型

ADT Queue
{
    数据对象：D = {ai | ai ∈ ElemType, i = 1, 2,...,n,n>=0}
    数据关系：R = {<ai-1,ai> | ai-1,ai ∈ D, i = 2, 3, ..., n} //约定a1端为队头，an端为队尾
    基本操作：
        InitQueue(Queue *Q);
            操作结果：建立一个空队列Q

        DestoryQueue(Queue *Q);
            初始条件：队列Q已存在
            操作结果：队列Q被销毁

        ClearQueue(Queue *Q);
            初始条件：队列Q已存在
            操作结果：队列Q被清空

        QueueLength(Queue Q);
            初始条件：队列Q已存在
            操作结果：返回队列Q的元素个数

        GetHead(Queue Q, ElemType *e);
            初始条件：队列Q为非空队列
            操作结果：用e返回Q的队头元素

        EnQueue(Queue *e, ElemType e);
            初始条件：队列Q已存在
            操作结果：插入元素e为Q的队尾元素
    
        DeQueue(Queue *e, ElemType *e);
            初始条件：队列Q为非空队列
            操作结果：删除Q的队头元素，用e返回值。
}

3.3.3 队列的顺序表示和实现

（1）队列的物理存储可以用顺序存储结构，也可以用链式存储结构，所以队列的存储方式也可以分为两种，即顺序队列和链式队列

（2）队列的顺序表示）——用一维数组base[MAXSIZE]

#define MAXSIZE 100 //顺序队列的最大长度
#typedef int ElemType;

#typedef struct SqQueue
{
    ElemType data[MAXSIZE]; //数据域
    int front;              //队头指针
    int rear;               //队尾指针
}SqQueue;

入队示意图：

 解决假上溢的方法：

 （1）出队时，将队中元素依次向队头方向移动；缺点：耗费时间

（2）将队空间设想成一个循环队列的表，就是分配给队列的MAXSIZE个存储单元可以循环使用，当rear为MAXSIZE时，若队列的开始端空着，就从头使用空着的空间，于此同理，front为MAXSIZE时，也是如此。

 3.3.4 循环队列的定义

        把队列的头尾相接的顺序存储结构称为循环队列。

 循环队列满队的情况：

第一种：

 第二种：

本文章使用的是第二种情况，第二种情况队满的条件是：，队列的长度是：。

 3.3.5 循环队列的实现

1、循环队列的初始化：

Status InitQueue(SqQueue *Q)
{
    Q->rear = Q->font = 0;
    return true;
}

2、求循环队列的长度

int QueueLength(SqQueue Q)
{
    return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}

3、循环队列取队头元素：

Status GetHead(SqQueue Q, ElemType *e)
{
    if (Q.front != Q.rear)
    {
        *e = Q.data[Q.front];
        return true;
    }
    return false;
}

4、循环队列入队操作：

Status EnQueue(SqQueue *Q, ElemTyp e)
{
    if ((Q.rear + 1) % MAXSIZE == Q.front)
        return false;

    Q->data[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAXSIZE;
    return true;
}

5、循环队列出队操作：

Status DeQueue(SqQueue *e, ElemType *e)
{
    if (Q->rear == Q->front)
        return false;

    *e = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return true;
}

3.3.6 队列的链式表示和实现

 

1、链队的类型定义：

typedef int ElemType;

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

typedef struct 
{
    QueuePtr front;  //队头指针
    QueuePtr rear;   //队尾指针
}LinkQueue;

 2、链队的初始化：

Status InitQueue(LinkQueue *e)
{
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
    if (Q->front == NULL)
        return false;

    Q->front->next = NULL;
    return true;
}

3、链队的销毁

Status DestoryQueue(LinkQueue *Q)
{
    QueuePtr *p;
    while (Q->front)
    {
        p = Q->front;
        Q->front = p->next;
        free(p);
    }
    Q->front = Q->rear = NULL;
    return true;
}

4、链队的入队操作：

Status EnQueue(LinkQueue *Q, ElemType e)
{
    QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    if (p == NULL)
        return false;

    p->data = e;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
    return true;
}

5、链队的出队操作：

Status DeQueue(LinkQueue *Q, ELemType *e)
{
    if (Q->front == Q->rear)
        return false;

    QueuePtr p;
    p = Q->front->next;
    *e = p->data;
    Q->front->next = p->next;

    if (Q->rear == p)
        Q->rear = Q->front

    free(p);
    p = NULL;
    return true;
}

6、链队取队头元素：

Status GetHead(LinkQueue Q, ElemType *e)
{
    if (Q.front == Q.rear)
        return false;

    *e = Q.front->next->data;
    return true;
}