本文根据《大话数据结构》一书，实现了Java版的循环队列、链队列。
队列：只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
1.循环队列
队列的顺序储存结构：用数组存储队列，引入front指针指向队头元素，rear指针指向队尾元素的下一个位置，当front=rear时，为空队列，结构如下图所示。
当执行入队操作时，若数组尾部已满，而数组前部因有元素出队而有空位时，我们把新插入的元素从头开始入队，这样就类似于头尾相接的结构。
队列的这种头尾相接的顺序存储结构称为循环队列，如下图所示。
上面队列的定义中提到，当front=rear时，为空队列，而在循环队列中，队列满时，front也等于rear，将无法判断队满和空的情况。
一种办法是设置一个标志变量flag，当front=rear时，通过判断flag是0还是1来确定队列满空情况；
另一种方法是，在数组中只剩一个空闲单位时，定义为队列满，如下图所示。（本文程序采用这种办法）
因为rear可能比front大，也可能比front小，所以队列满的条件应该为：(rear+1)%maxSize==front；同理，队列长度的计算公式为：(rear-front+maxSize)%maxSize。
实现程序：
/**
* <循环队列>
*
* 注意点：表长的表示、队列满的判断、front和rear的改变
*
* @author Lai
*
*/
public class SqQueue<E> {
private E[] data;
private int front;
private int rear;
private int maxSize;
private static final int DEFAULT_SIZE= 10;
/*
* 初始化
*/
public SqQueue(){
this(DEFAULT_SIZE);
}
public SqQueue(int maxSize){
data=(E[]) new Object[maxSize];
this.maxSize=maxSize;
front=0;
rear=0;
}
/*
* 求循环队列长度
*/
public int getLength() {
return (rear-front+maxSize)%maxSize;
}
/*
* 入队操作
*/
public void enQueue(E e) {
if((rear+1)%maxSize==front)
throw new RuntimeException("队列已满，无法入队！");
data[rear]=e;
rear=(rear+1)%maxSize;
//不是rear=rear+1，当rear在数组尾部时，后移一位会转到数组头部
}
/*
* 出队操作
*/
public E deQueue() {
if(rear==front)
throw new RuntimeException("队列为空！");
E e=data[front];
front=(front+1)%maxSize;
//不是front++，理由同rear
return e;
}
/*
* 打印操作
*/
public void printQueue() {
int k=front;
for(int i=0;i<getLength();i++) {
System.out.print(data[k]+" ");
k=(k+1)%maxSize;
}
System.out.println();
}
/*
* 测试代码
*/
public static void main(String[] args) {
SqQueue<String> aQueue=new SqQueue<>(5);
aQueue.enQueue("a");
aQueue.enQueue("b");
aQueue.enQueue("c");
aQueue.enQueue("d");
aQueue.printQueue();
System.out.println("-----");
aQueue.getLength();
aQueue.deQueue();
aQueue.deQueue();
aQueue.enQueue("e");
aQueue.printQueue();
}
}
a b c d ----- c d e
2.队列的链式存储结构
用单链表存储队列，称为链队列。
定义front指针指向头结点，rear指针指向终端结点，空队列时，front和rear都指向头结点。
实现程序：
/**
* 链队列
*
* 注意点：出队操作时，若队头是队尾（即队中仅有一个结点），则删除后要将rear指向头结点。
*
* @author Yongh
*
* @param <E>
*/
public class LinkQueue<E> {
private QNode front,rear;
private int count;
class QNode{
E data;
QNode next;
public QNode(E data,QNode next) {
this.data=data;
this.next=next;
}
}
public LinkQueue() {
front=new QNode(null, null);
rear=front;
count=0;
}
/*
* 入队操作
*/
public void enQueue(E e) {
QNode node=new QNode(e, null);
rear.next=node;
rear=node;
count++;
}
/*
* 出队操作
*/
public E deQueue() {
if(rear==front)
throw new RuntimeException("队列为空！");
QNode node=front.next;
E e=node.data;
front.next=node.next;
//若队头是队尾，则删除后要将rear指向头结点。
if(rear==node)
rear=front;
node=null;
count--;
//通过count来判断，可能更容易理解
//if(count==0)
// rear=front;
return e;
}
/*
* 获取队列长度
*/
public int getLength() {
return count;
}
/*
* 打印输出队列
*/
public void printQueue() {
if(count==0) {
System.out.println("空队列");
}else {
QNode node=front;
for(int i=0;i<count;i++) {
node=node.next;
System.out.print(node.data+" ");
}
System.out.println();
}
}
/*
* 测试代码
*/
public static void main(String[] args) {
LinkQueue<String> lQueue =new LinkQueue<>();
lQueue.printQueue();
lQueue.enQueue("A");
lQueue.enQueue("B");
lQueue.enQueue("c");
lQueue.enQueue("D");
lQueue.printQueue();
lQueue.deQueue();
lQueue.deQueue();
lQueue.enQueue("E");
lQueue.printQueue();
}
}
空队列
A B c D
c D E
3.循环队列和链队列的选择
基本操作时间都为O(1)。但链队列每次申请和释放结点会存在一点时间开销，且其需要存储一个指针域；而循环队列必须固定空间长度，存在空间浪费问题，且没链队列灵活。
综上，在可以确定队列长度最大值的情况下，建议用循环队列；当无法预估队列的长度时，使用链队列。