队列及循环队列和代码实现

之前我们提到了栈。栈是一种线性表，它是先进后出的，是FILO。
同时我们也存在一种线性表，是先进先出的。那就是队列。

一.队列

队列在平时我们生活中还是比较常用的。比如在操作系统中，就是这样的。哪些操作先进入的，哪些操作就先实现。
队列是只允许一端进行插入操作，另一端进行删除操作的线性表。
允许插入的一端称为队尾，允许删除称为队头。
如果是普通队列，那就是如果从队头出去，front就往后退一个。如果入队，那就rear往后一个。front都会在rear前面

但是现在如果已经到队尾了，前面刚好也有出队的。但是还是有入队的。该怎么处理呢？因为rear已经在最后了，没办法往前，但是前面还是有空位，这时候就比较尴尬了。

二.循环队列

这时候需要用到的是循环队列，rear是可以往前继续然后继续往后走了。这样可以操作的空间就很大了。只要队列不满，就可以继续入队。
我们把队列头尾相接的顺序存储结构称为循环队列。
**这样rear和front就没有前后之分了。**但这样也要注意什么时候是空队列什么时候是队满了。
首先，队空条件还是和之前一样，当front == rear，那么就队空了。
但是也不能队满也是这个判断吧。虽然队满也可能是front == rear。
现在队满条件可能有两个方案。

1. 设置一个标识变量flag,当front == rear ，且flag = 0为队列空。当front == rear，且flag = 1时队列满。
2. 当队列满时，保留一个元素空间，也就是说，队列满时，数组中还有一个空闲空间。
   
   所以这里的话，队满条件是（tail + 1）%capacity == front，capacity是最大尺寸。
   队列长度的话，
   当rear > front 时，长度为：rear - front
   当rear < front 时，可以将上图分成两部分看，一部分是front到f，一部分是g到rear。两端长度分别为 capacity-front，一部分是0+rear。加起来是rear - front+capacity。
   所以队列长度是（rear - front +capacity）% capacity

三.循环队列实现

循环队列实现结构：

#define MAXSIZE 10
typedef int QElemtype;
typedef int Status;
typedef struct{
	QElemtype data[MAXSIZE];
	int front;
	int rear;
}SQueue;

入队操作：

Status EnQueue(SQueue *Q,QElemtype e)
{
	if((Q->rear - Q->front + 1) % MAXSIZE == MAXSIZE)
		return ERROR;
	Q->data[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAXSIZE;
	return OK;
}

出队操作：

Status DeQueue(SQueue *Q,QElemtype *e)
{
	if(Q->front == Q->rear)
		return ERROR;
	*e = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAXSIZE;
	return OK;
}

总的代码：

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

#define OK 1
#define ERROR 0
#define MAXSIZE 10
typedef int QElemtype;
typedef int Status;
typedef struct{
	QElemtype data[MAXSIZE];
	int front;
	int rear;
}SQueue;


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

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

Status EnQueue(SQueue *Q,QElemtype e)
{
	if((Q->rear - Q->front + 1) % MAXSIZE == MAXSIZE)
		return ERROR;
	Q->data[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAXSIZE;
	return OK;
}

Status DeQueue(SQueue *Q,QElemtype *e)
{
	if(Q->front == Q->rear)
		return ERROR;
	*e = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAXSIZE;
	return OK;
}
int main(void)
{
	SQueue Q;
	QElemtype e;
	SQueue_Init(&Q);
	EnQueue(&Q,1000);
	EnQueue(&Q,655);
	printf("%d  ",Q.data[Q.rear - 1]);
	printf("%d ",Q.data[Q.front]);
	DeQueue(&Q,&e);
	printf("%d ",Q.data[Q.front]);
	return 0;
}

四.结束

如果我们使用的是普通的队列，那么算法时间性能不高。若是循环队列，也可能会数组溢出。那么可以使用队列的链式存储结构。
队列的链式存储