[数据结构] Data Structure(1) 之循环队列

队列的定义

队列简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除，操作特性是先进先出。

队头(Front)：允许删除的一端，又称为队首。
队尾(Rear)：允许插入的一端。
空队列：不含任何元素的空表。

为何要使用循环队列

为了解决假溢出
何为假溢出？

(a) 初始化队列，Q->front = Q->rear = 0;
(b) 每当有元素入队时，尾指针加1
© 每当有元素出队时，头指针加1
由此可以看出，虽然队尾已经走到了分配空间的最后一个空间，但是前面由于有元素出队，所以还有空间已经被释放没有用到，所以就引进了循环队列的概念。

细讲循环队列

初始化：Q->front = Q->rear = 0
队首指针进1：Q->front = (Q->front + 1) % MAXSIZE
队尾指针进1：Q->rear = (Q->rear + 1) % MAXSIZE
队列长度：(Q->rear + MAXSIZE - Q->front) % MAXSIZE

现在出现了一个大问题：如何判断队列为空和队列已满？
队空的条件是Q->front == Q->rear，如果现在入队的速度快过出队的速度，那么队尾指针将会很快地追上队首指针，也就是满队也是Q->front == Q->rear。如何解决这种问题呢？有三种解决方式：

1. 牺牲一个单元来区分队空和队满，这也是最常用的做法，如下图d2
   

队满条件为：(Q->rear + 1) % MAXSIZE == Q->front
队空条件为：Q->front == Q->rear
队列中元素个数：(Q->rear - Q->front + MAXSIZE) % MAXSIZE

2. 增加一个中间变量表示元素个数，队空条件为Q->size == 0，队满条件为Q->size == MAXSIZE，这两种情况都有Q->front == Q->rear。
3. 增加一个tag，以区分队空还是队满。tag = 0的情况下，若因删除导致Q->front == Q->rear则为队空；tag = 1的情况下，若因删除导致Q->front == Q->rear则为队满。

时间复杂度

· 读取时的时间复杂度为O(1)。
· 插入、删除时的时间复杂度为O(1)。

算法示例(牺牲单元)：

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20

typedef int Status;
typedef int ElemType;

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

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

//清空队列
Status ClearQueue(SqQueue *Q)
{
  Q->front = Q->rear = 0;
  return OK;
}

//判空
Status QueueEmpty(SqQueue Q)
{
  if(Q.front == Q.rear)
  {
    return TRUE;
  } else{
    return FALSE;
  }
}

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

//获取队列头元素
Status GetHeader(SqQueue Q, ElemType *e)
{
  if(Q.front == Q.rear)
    return ERROR;
  *e = Q.data[Q.front];
  return OK;
}

//插入元素
Status EnQueue(SqQueue *Q, ElemType 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, ElemType *e)
{
  if (Q->front == Q->rear)
    return ERROR;
  *e = Q->data[Q->front];
  Q->front = (Q->front + 1) % MAXSIZE;
  return OK;
}

//打印单个元素
Status visit(ElemType e)
{
  printf("%d", e);
  return OK;
}

//遍历队列
Status QueueTravel(SqQueue Q)
{
  printf("[ ");
  while (Q.front != Q.rear)
  {
    visit(Q.data[Q.front]);
    printf(" ");
    Q.front = (Q.front + 1) % MAXSIZE;
  }
  printf("]\n");
  return OK;
}

int main()
{
  Status status;
  int i = 0, j;
  ElemType e;
  SqQueue Q;

  InitQueue(&Q);
  printf("Is the queue empty after the queue is initialized? %s\n",QueueEmpty(Q)==1 ? "True":"False");
  
  for(j = 1; j <= 10; j++)
  {
    EnQueue(&Q, j);
  }

  printf("The value of the queue after inserting 10 elements is:\n");
  QueueTravel(Q);
  printf("QueueLength: %d\n",QueueLength(Q));
  printf("Is the queue empty after inserting 10 elements? %s\n", QueueEmpty(Q) ? "True":"False");
 
  printf("delete elements: \n");
  for (j = 0; j < 5; ++j)
  {
    DeQueue(&Q, &e);
    printf("element %d dequeued! \n", e);
  }
  printf("After the 5 elements are dequeued, the values in the queue are:\n"); 
  QueueTravel(Q);
  printf("QueueLength: %d\n",QueueLength(Q));

  status = GetHeader(Q, &e);
  if(status)
  {
    printf("The queue header element is: %d\n", e);
  }

  ClearQueue(&Q);
  printf("Whether the queue is empty after emptying the queue: %s\n", QueueEmpty(Q) == TRUE ? "True":"False");
  printf("The elements in the queue are:");
  QueueTravel(Q);
  return 0;
}

编译运行结果：