数据结构笔记3 队列（队列的顺序存储、链式存储）

队列简介

队列(Queue)：具有一定操作约束的线性表
插入和删除操作：只能在一端插入，而在另一端删除。可进行插入的一端称为队尾（Rear），可进行删除的一端称为队头（Front）。
数据插入：入队列（AddQ）
数据删除：出队列（DeleteQ）
先来先服务
先进先出：FIFO

队列的抽象数据类型描述
类型名称：队列(Queue)
数据对象集：一个有0个或多个元素的有穷线性表。
1、Queue CreatQueue( 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 )：将队头数据元素从队列中删除并返回。

队列的顺序存储实现

队列的顺序存储结构通常由一个一维数组和一个记录队列头元素位置的变量front以及一个记录队列尾元素位置的变量rear组成。

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

问：如果空队列开始时front和rear值都是-1，当插入4个元素并删除2个元素后，front和rear值分别是多少？
答：1和3
（插入n个元素，rear加n；删除n个元素，front加n）

1、入队列
（Front和rear指针的移动采用加1取余法，体现了顺序存储的“循环使用”。）

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;
}

ElementType DeleteQ ( Queue PtrQ )
{ 
 if ( PtrQ->front == PtrQ->rear ) { 
 printf(“队列空”);
 return ERROR;
 } else {
 PtrQ->front = (PtrQ->front+1)% MaxSize;
 return PtrQ->Data[PtrQ->front];
 }
}

队列的链式存储实现

队列的链式存储结构也可以用一个单链表实现。插入和删除操作分别在链表的两头进行；队列指针front和rear应该分别指向链表的哪一头？
队列的front设在链表的头，rear设在尾

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

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

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; }

在一个链表表示的队列中， f和r分别指向队列的头和尾。下列哪个操作能正确地将s结点插入到队列中：（B）
A.f->next=s; f=s;
B.r->next=s; r=s;
C.s->next=r; r=s;
D.s->next=f; f=s;

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

源代码汇总

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];
    }
}

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;
    }
}