【学习笔记----数据结构07-队列】

队列的定义

队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。

队列的抽象数据类型

同样是线性表，队列也有类似线性表的各种操作，不同的就是插入数据只能在队尾进行，删除数据只能在队头进行。

ADT 队列(Queue)

Data

 同线性表。元素具有相同类型，相邻元素具有前驱和后继关系

Operattion

 InitQueue(*Q) :初始化操作，建立一个空队列Q

 DestroyQueue(*Q): 若队列Q存在，则销毁它

 ClearQueue(*Q) :清空Q

 QueueEmpty(Q):若队列Q为空，返回true,否则返回false

 GetHead(Q,*e):若队列Q存在且非空，用e返回队列Q的队头元素。

 EndQueue(*Q,e):若队列Q存在，输入新元素e到队列Q中并成为队尾元素

 DeQueue(*Q,*e):删除队列Q中队头元素，并用e返回其值

 QueueLength(Q):返回队列Q的元素个数

endADT

循环队列

线性表有顺序存储和链式存储，栈是线性表，所以有两种存储方式。同样，队列作为一种特殊的线性表，也同样存在这两种存储方式。
队列顺序存储的不足

假设一个队列有n个元素，则顺序存储的队列需要建立一个大于n的数组，并把队列的所有元素存储在数组的前n个单元，数组下标为0的一即是队头。所谓的入队列操作，其实就是在队尾追加一个元素，不需要移动任何元素，因此时间复杂度为O（1）

与栈不同的是，队列元素的出列是在队头，即下标为0的位置，那么就意味着队列中的所有元素都得向前移动，以保证队列的队头，也就是下标为0的位置不为空，此时时间复杂度为O(n)

如果队头出队，而不移动元素，那么出队的性能就会大大增加。也就是说，队头不需要一定在下标为0的位置。为了避免当只有一个元素时，队头和附属重合，front指针指向队头元素，rear指针指向队尾元素的下一个位置，当front==rear时此队列为空。

假设是长主为5的数组，初始状态，空队列。front与rear指针均指向下标为0的位置。然后a1/a2/a3/a4，入队front指针依然指向下标为0位置，而rear指针指向下标为4的位置。

出队a1、a2，则front指针指向下标为2的位置，rear不变，再入队a5，此时front指针不变，rear指针移动到数组之外 ，这种现象是假溢出。
循环队列定义

所以解决假溢出的办法就是后面满了，就再从头开始，也就是头尾相接的循环。我们把队列的头尾相接的顺序存储结构称为循环队列。

接着上面a6入队，将它放置于下标为0处，rear指针指向下标为1处，若再入队a7，则rear指针就与front指针重合，同时指向下标为2的位置。

1. 此时问题又出来了，我们刚才说，空队列时，front等于rear，现在当队列满时，也是front等于rear那么如何判断此时的队列空间是空还是满呢？
2. 办法是设置一个标志变量flag，当front==rear，且flag=0队列空，当front==rear且flag=1时队满

办法二是当队列空时，条件就是front==rear，当队列满时，我们修改其条件，保留一个元素空间。也就是说队列满时，数组中还有一个空闲的单元，

我们重点来讨论第二种方法，由于rear可能比front大，也可能比front小，所以尽管它们只相差一个位置时就是满情况，但也可能是相差整整一圈。所以若队列的最大尺寸为QueueSize，那么队列满的条件是（rear+1）%QueueSize==front

通用的计算队列长度的公式：（rear-front+QueueSize）%QueueSize

循环队列的顺序存储结构代码：

typedef int  QElemType
typedef struct
{
     QElemType   data[MAXSIZE];
     int   front;
     int   rear;
}SqQueue;

//初始化代码
Status InitQueue(SqQueue  *Q)
{
   Q->front=0;
   Q->rear = 0;
    return OK;
}

//求队列长度
int  QueueLength(QqQueue  Q)
{
    return   (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}

//入队操作
status  EnQueue(SqQueue  *Q,QElemType  e)
{
     if((Q->rear+1)%MAXSIZE==Q->front)
         return ERROR;
     Q->data[Q->rear]=e;
     Q->rear = (Q-rear+1)%MAXSIZE;
     return OK;
}

//出队操作
status  DeQueue(SqQueue  *Q,QElemType  *e)
{
     if(Q->front==Q->rear)
         return ERROR;
     *e = Q->data[Q->front];
      Q->front = (Q->front+1)%MAXSIZE;
     return OK;
}

队列的链式存储结构及实现

队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。

//结点结构
typedef  struct  QNode
{
    QElemType   data;
    struct  QNode  *next;
}QNode,*QueuePtr;

//队列的链表结构
typedef  struct
{
    QueuePtr   front,rear;
}LinkQueue;

队列的链式存储结构—-入队操作

入队操作时，其实就是在链表尾部插入结点。

Status EnQueue (LinkQueue *Q,QElemType  e)
{
   QueuePtr  s = (QueuePtr)malloc(sizeof(QNode));
   if(!s)
      exit(OVERFLOW);
      s->data = e;
      s->next = NULL;
      Q->rear->next = s;
      Q->rear = s;
      return  OK;
}

队列的链式存储结构—-出队操作

出队操作时，就是头结点的后继结点出队，将头结点的后继改为它后面的结点，若链表除头结点外只剩一个元素时，则需将rear指向头结点

/*若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR*/

Status DeQueue (LinkQueue *Q,QElemType  *e)
{
     QueuePtr  p;
     if(Q->front==Q->next)
        return  ERROR;
     p=Q->front->next;  //将欲删除的队头结点暂存给p
     *e = p->data;   //将欲删除的队头结点的值赋值给e
      Q->front->next=p->next; //将原队头结点后继p->next赋值给头结点后继
       if(Q->rear==p)
           Q->rear=Q->front;
        free(p);
        return OK;
}