队列

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

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

队列可按存储结构分为顺序队列和链队列。

我们把头尾相接的顺序存储结构称为循环队列。

front指针指向队头元素，rear指向队尾元素的下一个位置。

队列长度：(rear - front + MAXSIZE) % MAXSIZE

队列为空：rear == front

队列为满：(rear + 1) % MAXSIZE == front

循环队列的存储结构：

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

循环队列的长度：

int QueueLength(SqQueue Q)
{
	return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}

循环队列的初始化：

Status InitQueue(SqQueue *Q)
{
	Q->front = 0;
	Q->rear = 0;
	return OK;
}

循环队列的入队列：

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->rear == Q->front)
		return ERROR;
	*e = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAXSIZE;
	return OK;
}

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

队头指针指向链队列的头结点，队尾指针指向终端结点。

链队列的结构：

typedef int QElemType;
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;
}

链队列的出队操作：

Status DeQueue(LinkQueue *Q, QElemType *e)
{
	QueuePtr p;
	if (Q->front == Q->rear)
		return ERROR;
	p = Q->front->next;
	*e = p->data;
	Q->front->next = p->next;
	if (p == Q->rear)
		Q->rear = Q->front;
	free(p);
	return OK;
}

循环队列和链队列的基本操作都是时间常数，都为 O(1)。