前提理解
对前面的顺序数组模拟队列进行优化，充分利用数组，将数组看做是一个环形的，通过取模的方式来实现模拟环形结构即可。
环形队列：最大容量本质是maxSize-1，其中一个位置不填充队列数据；
front:指向环形队列的第一个数据，也就是说arrQueue[front]就是队列的第一个元素，初始front=0
rear :指向环形队列最后一个元素的后面一个位置。初始rear=0
不管是front还是rear,在环形队列中，都是先赋值，再进行+1操作，进行后移。
添加元素的过程理解：
- 首先判断队列是否是满的；
- 将元素添加到当前的rear位置处的数组处；
- 将rear++，
- 完成添加操作之后的状态为，队列数组对应的rear位置添加上了新元素，但是rear指针指向了新元素的下一个位置；
思路分析
- 初始化一个数组大小为6的环形队列数组
array[6], 头指针front=0, 尾指针rear=0, 刚好front== rear ==0的状态,表示环形队列为空；
下图为初始化状态下的环形队列。
- 向环形队列里插入1个元素,则rear指针移动一格
,插入第一个元素之后，front==0,rear==1， 插入一个元素的具体操作顺序如下，先不考虑判断队列是否满的情况。首先array[rear==0]=a1,然后rear++;
- 继续添加a2,a3,a4,a5元素,当把a5插入之后，即
array[rear==4]=a5,rear++变为rear==5,指针指到末尾处,也就是此时front==0, rear==5，rear指向了数组的最后一个位置；
- 此时如果继续按照上述的步骤添加a6元素到array[5]这个位置，那么添加完之后，rear++就变成了rear==6,此时我们知道如果继续添加那就是array[6],这时候就发生了数组越界了。
- 如上图所示添加a6时,rear指针发生溢出。这时候我们使用一个小技巧,当rear==5时候，首先先判断队列是否满了，使用数组大小maxSize==6进行取模, (rear+1) % maxLen,即(5+1)%6==0，达到了模拟环形数组的结构，让rear指针回到开始处rear=0,问题来了,这时候我们无法判断数组是否满?因为初始化时front=rear=0, 现在数组满也是front=rear=0
- 如何解决上述的冲突，有一个常用的方法就是将整个队列数组的容量少用一个 少用一个位置的结果就是：
1） 整个队列的最大容量本质就是maxSize-1了；
2） 不用的这个位置还是动态变化的，能够更好的让我们用来区分队满和队空，解决上述的问题；
3） 上述例子中array[5]就是不用的位置，因为在进行添加数据之前，我们需要判断队列是否满，利用的就是(rear+1)%maxSize ==front这个算法。利用该算法，就会使得我们每当最后添加的那个元素始终跟队列头的第一个元素之间隔了一个不用的元素。
代码示例
package com.ethan.queue;
import java.util.Scanner;
import org.junit.Test;
public class CircleArrayQueueDemo {
@Test
public void CircleArrayQueueTest() {
// 初始化一个队列
CircleArray queue = new CircleArray(6);
char key = ' ';
Scanner scanner = new Scanner(System.in);
boolean loop = true;
while(loop) {
System.out.println("s(show):显示队列");
System.out.println("a(add): 添加数据到队列");
System.out.println("g(get): 取出队列头数据");
System.out.println("h(head):查看头队列");
System.out.println("e(exit):退出程序");
key = scanner.next().charAt(0);
switch (key) {
case 's':
queue.showQueue();
break;
case 'a':
System.out.println("请输入一个数据：");
int data = scanner.nextInt();
queue.addQueue(data);
break;
case 'g':
try {
int valueQueue = queue.getQueue();
System.out.println("取出的队列头数据为："+valueQueue);
} catch (Exception e) {
// TODO: handle exception
System.out.println(e.getMessage());
}
break;
case 'h':
try {
int valueHead = queue.headQueue();
System.out.println("查看队列头数据为："+valueHead);
} catch (Exception e) {
// TODO Auto-generated catch block
System.out.println(e.getMessage());
}
break;
case 'e':
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出···");
}
}
/**
* 环形队列：最大容量其实是maxSize-1
* front:指向环形队列的第一个数据，也就是说arrQueue[front]就是队列的第一个元素，初始front=0
* rear :指向环形队列最后一个元素的后面一个位置。初始rear=0
*
* 1.队列空的判断:rear==front,前提是环形队列arr[]数组的最大容量maxSize少用一个位置。
* 原因是假设maxSize==6,那么当arr[rear==4]=a5时候，此时还剩最后一个位置arr[5]为空，
* 假如将arr数组填满，此时rear==5,先判断队列是否满了，那么(rear+1)%maxSize==0==front,这时候问题来了，
* 我们无法判断数组是否满?因为初始化时front=rear=0, 现在数组满也是front=rear=0
*
*
* 2.队列满的判断:(rear+1)%maxSize ==front
* 3.队中元素个数n＝（rear-front+maxSize)%maxSize
* 4.入队：rear=(rear+1) % maxSize ;
* 5.出队：front=(front+1) % maxSize ;
*
* @author ethan
*
*/
class CircleArray{
private int maxSize;//代表队列数组的最大容量
private int front;//代表队列头
private int rear;//代表队列尾
private int[] arrQueue;//代表环形队列数组
//1.初始化一个队列，构造函数
public CircleArray(int arrMaxSize){
maxSize = arrMaxSize;
arrQueue = new int[maxSize];
front = 0;// 指向环形队列的第一个数据，初始front=0
rear = 0;// 指向环形队列最后一个元素的后面一个位置，该位置为空。初始rear=0
}
//2.判断是否为空,如果头指针和尾指针相等，代表队列中无数据
public boolean isEmpty() {
return front == rear;
}
//3.判断队列是否满，(rear+1)%maxSize ==front
public boolean isFull() {
return (rear+1)%maxSize == front;
}
//4.添加队列数据
public void addQueue(int queueData) {
// 判断队列是否满
if(isFull()) {
System.out.println("队列已满，无法添加新数据！");
return ;
}
arrQueue[rear] = queueData;
rear = (rear + 1)%maxSize;
}
//5.取队列数据
public int getQueue() {
if(isEmpty()) {
throw new RuntimeException("队列为空，不能取数据！");
}
int value = arrQueue[front];
front = (front+1)%maxSize;
return value;
}
//7.查看队列中数据
public void showQueue() {
if(isEmpty()) {
System.out.println("队列为空！");
return ;
}
for (int i = front; i < front+size(); i++) {
System.out.printf("arrQueue[%d]=%d\n", i % maxSize, arrQueue[i % maxSize]);
}
System.out.println();
}
//8.队列中的有效数据的多少
public int size() {
return (rear+maxSize-front)%maxSize;
}
//9.查看头队列数据
public int headQueue() {
if(isEmpty()) {
throw new RuntimeException("队列为空，无法查看数据！");
}
return arrQueue[front];
}
}
总结
记住以下关键点
- 环形队列：最大容量其实是maxSize-1
- front:指向环形队列的第一个数据，也就是说arrQueue[front]就是队列的第一个元素，初始front=0
- rear :指向环形队列最后一个元素的后面一个位置。初始rear=0
- 不管是front还是rear,在环形队列中，都是先赋值，再进行+1操作，进行后移。
-
- 队列空的判断:rear==front,前提是环形队列arr[]数组的最大容量maxSize少用一个位置。
-
- 队列满的判断:(rear+1)%maxSize ==front
-
- 队列元素个数size=(rear-front+maxSize)%maxSize
-
- 入队：rear=(rear+1) % maxSize ;
-
- 出队：front=(front+1) % maxSize ;
