队列
队列是只允许在一端进行插入，在另一端进行删除的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO，允许插入的一端叫队尾，允许删除的一端叫队头。
线性表有顺序存储和链式存储，栈是线性表，所以有这两种存储方式，同样，队列作为特殊的线性表，也有两种存储方式。
队列的顺序存储结构：
假设我们有一个n个元素队列，则顺序存储的队列需要一个大于n的数组，并且把队列的元素存储到数组的前n个单元里，数组下标为0的是队头，入队操作就是在队尾添加一个元素，因为不需要移动任何元素，时间复杂度为O(1)，如下图：
队列元素的出列是在队头，也就是下标为0的地方，那么意味着队列中的所有元素都要往前移动，保证队头不为空，时间复杂度为O(n)，如下图：
上面说到了出列需要把所有元素都往前移，那么我们如果不移动可不可以呢？
如果我们去掉了队列的元素必须存储在数组前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移到数组之外，如下图：
这样就会出现一个假溢出的状况，因为数组末尾元素已经被占用，再往后加，就会出现数组下标越界的问题，但是我们0和1的地方其实还空着，解决这种问题的方法就是后面满了，在从头开始，也就是头尾相接的循环，我们把这种队列称为循环队列。
接着上面的例子，我们将rear指针指向下标为0的地方
接着入队a6,将它放置于下标为0处，rear指向下标为1的地方
接着入队a7，则rear和front重合，同时指向下标为2的地方
刚刚我们提到了空队列时front等于rear，现在当队列满了的时候front也等于rear,那我们怎么区分呢？
我们有两种方法：
- 办法一设置一个标志变量flag,当front==rear，且flag=0时队列为空，当front==rear,且flag=1时队列满
- 办法二当队列为空时，front==rear,当队列满时，我们保留一个元素空间，也就是队列满时，数组中还有一个空闲单元,如下图所示，
我们重点讨论第二种方法，由于rear可能比front大，也有可能比front小，所以他们只相差一个情况下就是满的情况，但也可能差整整一圈，所以若队列的最大长度为QueueSize,那么队列满的条件是（rear+1）%QueueSize == front,比如上图所示，QueueSize=5.当上图左边中front=0.rear=4,(4+1)%5=0,所以此时队列已满。如上图右边所示，front=2,rear=1,(1+1)%5=2,所以此时队列也是满的。通用的计算队列长度公式为：（rear-front+QueueSize）%QueueSize
循环队列顺序存储结构实现代码：
class MyCircularQueue {
private int[] data;
private int front;
private int rear;
private int MaxLen;
/** Initialize your data structure here. Set the size of the queue to be k. */
public MyCircularQueue(int k) {
data = new int[k];
front = -1;
rear = -1;
MaxLen = k;
}
/** Insert an element into the circular queue. Return true if the operation is successful. */
public boolean enQueue(int value) {
if (isFull()){
return false;
}
if (isEmpty()){
front = 0;
}
rear = (rear+1)%MaxLen;
data[rear] = value;
return true;
}
/** Delete an element from the circular queue. Return true if the operation is successful. */
public boolean deQueue() {
if(isEmpty()){
return false;
}
if (front == rear) {
front = -1;
rear = -1;
return true;
}
front = (front + 1) % MaxLen ;
return true;
}
/** Get the front item from the queue. */
public int Front() {
if(isEmpty()){
return -1;
}
return data[front];
}
/** Get the last item from the queue. */
public int Rear() {
if(isEmpty()){
return -1;
}
return data[rear];
}
/** Checks whether the circular queue is empty or not. */
public boolean isEmpty() {
return front == -1 ;
}
/** Checks whether the circular queue is full or not. */
public boolean isFull() {
return (rear + 1) % MaxLen == front;
}
}队列的链式存储结构：
队列的链式存储结构其实就是线性表的单链表，只不过它能尾进头出，简称为链队列。我们将队头指针指向链队列的头结点，而队尾指向终端节点。
空队列时，front和rear都指向头结点
链队列代码实现
package linkqueue;
public class LinkQueue {
class Element
{
Object elem;
Element next;
}
private Element front;
private Element rear;
private Element header = null;
/**
* 初始化队列
* */
void initQueue()
{
header = new Element();
front = new Element();
rear = new Element();
front=header;
rear=header;
}
/**
* 向队列插入元素
* */
void enQueue(Object o)
{
Element e=new Element();
e.elem=o;
if(rear==header)//第一次插入元素
{
rear=e;
header.next=e;
front.next=e;
}else
{
rear.next=e;
rear=e;
}
}
/**
* 出队
* */
Object deQueue()
{
Object o = null;
if(rear==header)
{
System.out.println("队列为空！");
}else
{
o=front.next.elem;
if(front.next==rear)//队中只有一个元素
{
front.next=header;
rear=header;
}else//队中大于一个元素
{
front.next=front.next.next;
}
}
return o;
}
/**
* 打印队列
* */
void print()
{
System.out.print("打印队列：");
Element temp = front;
while(temp!=rear)
{
System.out.print(temp.next.elem+" ");
temp=temp.next;
}
System.out.println();
}
}循环队列和链队列的区别：
对于循环队列和链队列的比较，从时间上来讲，他们的基本的操作都是常数时间，都是O(1)，不过循环队列是事先申请好空间，试用期间不释放，而对于链队列，每次申请和释放结点也会消耗一定的时间。对于空间上来说，循环链表必须有固定长度，所以就有了存储空间浪费的问题，而链队列不存在这个问题，尽管它需要一个指针域，但这是可以接受的，所以空间上链队列更灵活。总的来说，在确定队列最大长度的情况下，建议循环队列，无法预估长度时使用链队列。