数据结构之队列

参考书籍《大话数据结构》

---

队列简介

 队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。它是一种先进先出（First In First Out)的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端称为队头。

队列的抽象数据类型：

ADT  队列(Queue)
Data
  同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation 
  InitQueue(* Q): 初始化操作，建立一个空队列Q；
  DestroyQueue(* Q): 若队列Q存在，则销毁它；
  ClearQueue(* Q): 将队列Q清空；
  QueueEmpty( Q ): 若队列Q为空，返回true，否则返回false；
  GetHead(Q, *e)： 若队列Q存在且非空，用 e 返回Q的队头元素；                          
  EnQueue(*Q,e)：若队列Q存在，插入新元素e到队列Q中并成为队尾元素；
  DeQueue(*Q, *e):删除队列Q中队头元素，并用e返回其值；
  QueueLength(Q): 返回队列Q的元素个数
endADT

循环队列—顺序结构：

 队列相当于现实生活中排队，入队则是直接在队尾后面加一个元素，而出队头(第一个人走)，后面人全部重新前进一步，但这样需要动的元素比较多，无需动的话性能会提升很多，就是说队头不一定要在下标为0的位置。

 定义两个指针，front指针指向队头元素，rear指针指向队尾元素的下一个位置，当front等于rear时，只有一个元素，队头和队尾重合处理会比较麻烦，故剩下一个元素时为空队列。
 把队列的头尾相接的顺序存储结构称为循环队列。
队列说明：
 由于空队列和队列满时都是front == rear；故要区分空队列和队列满需要做处理。
 方法一：设置标志变量flag，flag为1和0时，上面的情况就分为不同的情况。
 方法二：修改一个条件，保留一个元素位置，见下图

 由于是循环队列，故rear可能比front大，也可能小，所以若队列的最大尺寸为QueueSize，那么队列满的条件是(rear+1)%QueueSize == front(取模%的目的是为了整合rear与front大小为一个问题)。

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

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

循环队列求队列长度代码：

/*返回Q的元素个数，也就是队列的当前长度*/
int QueueLength(SqQueue Q)
{
  return (Q.rear-Q.front + MAXSIZE) % MAXSIZE;
}

入队列操作：

/*若队列未满，则插入元素e 为 Q新的队尾元素*/
Status EnQueue(SqQueue *Q, QElemType e)
{
  /*队列满的判断*/
  if((Q->rear+1)%MAXSIZE == Q->front)   
  {
    return ERROR;
  }
  /*将元素e赋值给队尾*/
  Q->data[Q->rear] = e;      
  /*rear指针向后移动一个位置，若到最后则转到数组头部*/
  Q->rear = (Q->rear+1) %MAXSIZE; 
  return  OK;
}

出队列操作：

/*若队列不空，则删除Q中队头元素，用 e 返回其值*/
Status  DeQueue(SqQueue *Q , QElemType *e)
{
  /*队列空的判断*/
  if(Q->front== Q->rear)        
  {
    return ERROR;
  }
  /*将队头元素赋值给e*/
  *e = Q->data[Q->front];       
  /*front 指针向后移一位置*/
  Q->front = (Q->front + 1) % MAXSIZE;  
  return OK;
}

队列的链式存储结构

 队列的链式存储结构，就是加了限制的线性表的单链表，只能尾进头出而已，简称为链队列。
正常结构：

空队列：front 和 rear 都指向头结点

链队列结构：

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

typedef  struct                        /*队列的链表结构*/
{
  QueuePtr  front,rear;     /*队头、队尾指针*/
}LinkQueue;

入队操作:

 入队操作就是在链表尾部插入结点。

/*插入元素e 为Q 的新的队尾元素*/
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->rear)
  {
    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;
}

对比：

 循环队列和链队列，从时间上两者都是O(1)，不过循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点会存在一些时间开销，如果出队入队过于频繁，两者也会有差异。从空间来讲，循环队列必须要有固定的长度，而链队列不需要，所以链队列在空间上比较灵活。即能预估队列长度就用循环队列，不能则用链队列。