MOOC 数据结构 | 2. 线性结构（3）：队列及实现

3. 队列

3.1 什么是队列

• 数据插入：入队列（AddQ）
• 数据删除：出队列（DeleteQ）
• 先来先服务
• 先进先出：FIFO

3.2 队列的抽象数据类型描述

类型名称：队列（Queue）   数据对象集：一个有0个或多个元素的有穷线性表   操作集：长度为MaxSize的队列Q∈Queue，队列元素item∈ElementType   1、Queue CreateQueue(int MaxSize)：生成长度为MaxSize的空队列； 2、int IsFullQ(Queue Q, int MaxSize):判断队列Q是否已满； 3、void AddQ(Queue Q, ElementType item):将数据元素item插入队列Q中； 4、int IsEmptyQ(Queue Q)：判断队列Q是否为空； 5、ElementType DeleteQ(Queue Q):将队头数据元素从队列中删除并返回。

3.3 队列的顺序存储实现

3.3.1 结构体定义

#define MaxSize <存储数据元素的最大个数>
struct QNode 
{
    ElementType Data[MaxSize];
    int rear;
    int front;
};
typedef struct QNode *Queue;

【例】一个工作队列

一开始队列为空的，将Front和Rear都设为-1：

往队列里加入一个工作，Rear指向0：

再加一个工作，Rear往后挪，也就是加1：

再加一个工作：

接下来删除一个工作job1，Front + 1：

   

即是添加一个元素的时候，Rear +1；删除一个元素的时候，Front + 1。

假设队列现在已经到了这个状态：

这时来了Job 8：

可以将job 8放到数组下标为0位置处。

所以这样就形成了顺环队列。

顺环队列

Rear指向实际元素的位置，而Front指向的是第一个元素的前一个位置。

队列空：front == rear

1、加入一个元素Job 1：

（Front保持不动，还在0的位置；Rear在1的位置）

2、再加入元素Job 2：

3、加入元素Job 3：

4、删除Job 1：

5、加入Job 4：

6、加入Job 5：

 

7、加入Job 6：

8、此时再来一个Job，如果加入到1位置处，队列就满了，且Front和Rear相等。但是前面说Front = Rear表示队列空。所以Front == Rear：队列是满还是空？无法判断。

思考：

（1）这种方案：队列空和满的判别条件是什么？

答：根据front和rear的差距来判断的。

（2）为什么会出现空、满无法区分？根本原因？

答：就上面的问题来说，

front和rear“差距”有6种情况：0、1、2、3、4、5 --->如果数组大小为n，那front和rear的差距有n种情况。

队列装载元素个数情况有7种：0（空队列）、1（一个元素）、2、3、4、5、6  --->如果数组大小为n，队列装在元素个数情况有n+1种。

也就是说用n种状态来区分n+1种情况，是不可能的。好比用01来区分3种情况是做不到的。

解决方案：

（1）使用额外标记：Size或者tag域

       说明：Size来记录当前队列中的元素个数，加入一个元素，Size+1,；删除一个元素，Size - 1。根据Size的值来判断为空还是满。

                  tag（0或1），当插入一个元素的时候，tag = 1；删除一个元素，tag = 0；当front和rear相等时，判断这个tag，这个tag表示了最后一次是插入还是删除。

（2）仅使用n-1个数组空间

       说明：数组为n，但是只放n-1个位置。如上面这个状态表示队列满了，不能再放了。所以此时的判断条件：

• 如果rear+1 = front：队列满
• 如果rear == front：队列空

3.3.2 入队列

采取上述的第二种方案，不放满。

因为是循环地放置元素，就拿上面的例子来说，位置5放了元素，再放就要放到位置0上，那么怎么实现5后面是0呢，就用求余函数。（5+1）% 6 = 0。

void AddQ(Queue PtrQ, ElementType item)
{
    if((PtrQ->rear+1) % MaxSize == PtrQ->front)
    {
        printf("队列满");
        return;
    }
    PtrQ->rear = (PtrQ->rear+1) % MaxSize;
    PtrQ->Data[PtrQ->rear] = item;
}

3.3.3 出队列

ElementType DeleteQ(Queue PtrQ)
{
    if(PtrQ->front == PtrQ->rear)
    {
        printf("队列空");
        return ERROR;
    }
    else 
    {
        PtrQ->front = (PtrQ->front+1) % MaxSize; //赋值后front正好指向队列第一个元素的位置
        return PtrQ->Data[(PtrQ->front)];
    }
}

3.3.4 操作集完整代码

typedef int Position;
struct QNode {
    ElementType *Data;     /* 存储元素的数组 */
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;
 
Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}
 
bool IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}
 
bool AddQ( Queue Q, ElementType X )
{
    if ( IsFull(Q) ) {
        printf("队列满");
        return false;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MaxSize;
        Q->Data[Q->Rear] = X;
        return true;
    }
}
 
bool IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}
 
ElementType DeleteQ( Queue Q )
{
    if ( IsEmpty(Q) ) { 
        printf("队列空");
        return ERROR;
    }
    else  {
        Q->Front =(Q->Front+1)%Q->MaxSize;
        return  Q->Data[Q->Front];
    }
}

3.4 队列的链式存储实现

考虑到插入和删除操作（单向链表尾删除不知道前一个元素是什么），所以front指向链表的表头，rear指向链表的表尾。

3.4.1 结构体定义

struct Node  //链表的结点结构
{
    ElementType Data;
    struct Node *Next;
};
struct QNode //链队列结构
{
    struct Node *rear; //指向队尾结点
    struct Node *front; //指向队头结点
};
typedef struct QNode *Queue;
Queue PtrQ;

与代码的对应关系：

        

3.4.2 出队

不带头结点的链式队列出队操作的一个示例：

ElementType DeleteQ(Queue PtrQ)
{
    struct Node *FrontCell;
    ElementType FrontElem;

    if(PtrQ->front == NULL)
    {
        printf("队列空");
        return ERROR;
    }

    FrontCell = PtrQ->front;
    if(PtrQ->front == PtrQ->rear) //若队列只有一个元素
        PtrQ->front = PtrQ->rear = NULL; //删除后队列置为空
    else
        PtrQ->front = PtrQ->front->Next;
    FrontElem = FrontCell->Data;
    free(FrontCell);   //删除被释放结点空间
    return FrontElem;
}

FrontCell即为如下这个元素：

 → 

队列只有一个元素时，删除了之后，rear是会变的；如果队列不止一个元素，删除了第一个元素后，rear是不变的。所以要特殊处理队列只有一个元素的情况。

3.4.3 入队

Queue AddQ(Queue PtrQ, ElementType item)
{
    struct Node *TmpCell;
    TmpCell = (struct Node)malloc(sizeof(struct Node));
    TmpCell->Data = item;
    TmpCell->Next = NULL;
    if (PtrQ->front == NULL) //队列为空，则新结点既是队首结点也是队尾结点
       PtrQ->front = PtrQ->rear = TmpCell;
    else 
    {
        PtrQ->rear->Next = TmpCell; //将新结点链接到队尾，并将rear指向它
        PtrQ->rear = TmpCell;
    }
    return PtrQ;
}

3.4.4 操作集完整代码

typedef struct Node *PtrToNode;
struct Node { /* 队列中的结点 */
    ElementType Data;
    PtrToNode Next;
};
typedef PtrToNode Position;
 
struct QNode {
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;
 
bool IsEmpty( Queue Q )
{
    return ( Q->Front == NULL);
}
 
ElementType DeleteQ( Queue Q )
{
    Position FrontCell; 
    ElementType FrontElem;
     
    if  ( IsEmpty(Q) ) {
        printf("队列空");
        return ERROR;
    }
    else {
        FrontCell = Q->Front;
        if ( Q->Front == Q->Rear ) /* 若队列只有一个元素 */
            Q->Front = Q->Rear = NULL; /* 删除后队列置为空 */
        else                     
            Q->Front = Q->Front->Next;
        FrontElem = FrontCell->Data;
 
        free( FrontCell );  /* 释放被删除结点空间  */
        return  FrontElem;
    }
}

3.5 小测验

1. 在一个链表表示的队列中， f和r分别指向队列的头和尾。下列哪个操作能正确地将s结点插入到队列中：

(在链表尾插入新结点,r指向最后一个结点）

1. 现采用大小为10的数组实现一个循环队列。设在某一时刻，队列为空且此时front和rear值均为5。经过若干操作后，front为8，rear为2，问：此时队列中有多少个元素？

（front指向的是第一个元素的前一个位置，也就是说实际有元素的是从9 ~ 2，数组大小为10，所以一共就4个）