Java数据结构与算法------队列

队列是一种常见的数据结构，它是线性的，连续的，遵循先进先出原则。
在JAVA中我们可以利用队列的性质，通过数组模拟队列。

用数组来模拟队列

如上图，分别是用数组模拟队列的一个空队列，插入3个元素后的队列，取出1个元素后的队列。思想如下：

1. 先定义一个数组的最大容量MaxSize，指向队列头部的指针front，指向队列尾部的指针rear，定义一个数组arr。
2. 数组的大小为MaxSize，front和rear在初始时因为没有元素，设值为-1。
3. 当插入数据时，rear改变，每插入一个数据，rear+1.
4. 打取出一个数据时，front改变，每取出一个数据front+1.
5. 当rear=MaxSize-1时，队列为满。
6. 当reat=front时，队列为空。

但当我们开始编程时会发现这个队列并不完整，它是一次性的，当队列为满后，取出数据，再加入数据会发现显示还是队列为满。
因此，我们需要对它进行改进。

数组模拟环形队列

我们可以在原来的队列上修改得到一个环形队列，思路如下：

1. 使front指向队列的第一个元素，此时arr[front]就是队列的第一个元素。front初始值设为0.
2. 使reat指向队列的最后一个元素的后一个位置，空出一个空间作为约定。reat初始值设为0。
3. 当队列满时，（rear+1）%MaxSize = front。
4. 当队列空时，rear = front
5. 队列中有效数据的个数（rear+MaxSize-front）%MaxSize

更具体思想会在代码内进行注释

修改后代码如下：

package queue;

import java.util.Scanner;

public class CircleArrayQueue {//用数组模拟环形队列

	public static void menu() {
		System.out.println("s(show):显示队列");
		System.out.println("e(exit):退出程序");
		System.out.println("a(add):向队列添加数据");
		System.out.println("g(get):取出队列数据");
		System.out.println("h(head):查看队列头部数据");
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("测试一下数组模拟环形队列");
		
		CircleArray aq = new CircleArray(4);//设置为4，队列的有效数据最大为3
		char key = ' ';//接收用户的输入
		Scanner scanner = new Scanner(System.in);
		boolean loop=true;
//		key = scanner.next().charAt(0);
		while(loop) {
			menu();
			key = scanner.next().charAt(0);
			switch(key) {
			case 's'://显示队列
				aq.showQueue();
				break;
			case 'a'://向队列添加数据
				System.out.println("请输入一个数");
				int value = scanner.nextInt();
				aq.addQueue(value);
				break;
			case 'g'://取出队列数据
				try {
					int res=aq.getQueue();
					System.out.printf("取出的数据是%d\n",res);
				}catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 'h'://查看队列头部数据
				try {
					int res=aq.headQueue();
					System.out.printf("队列头部的数据是%d\n",res);
				}catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 'e'://退出程序
				scanner.close();
				loop = false;
				break;
			default:
				break;
			}
		}
		
		System.out.println("程序退出");
	}

}


class CircleArray{
	//首先定义初始化变量
	private int maxsize;//表示数组（队列）的最大容量
	private int front;//使front指向队列的第一个元素，此时arr[front]就是队列的第一个元素。front初始值设为0.
	private int rear;//使reat指向队列的最后一个元素的后一个位置，空出一个空间作为约定。reat初始值设为0。
	private int[] arr;//定义一个数组
	
	public void sop(Object obj) {
		System.out.println(obj);
	}
	
	public CircleArray(int arrMaxSize) {
		maxsize = arrMaxSize;//给定参数指定队列的容量
		arr = new int[maxsize];//创建该容量大小的数组
	}
	
	//判断队列是否已满
	public boolean isFull() {
		return (rear+1)%maxsize == front;//rear指向的是最后一个元素的后一个元素，所以rear=maxsize-1，rear+1%maxsize=0就为满
	}
	
	//判断队列是否为空
	public boolean isEmpty() {
		return front == rear;//如果队首指针等于队尾指针，那么此时队列是空的
	}
	
	//向对列中添加数据
	public void addQueue(int n) {
		//先判断队列是否为满
		if(isFull()) {
			sop("此时队列已满，因此不能加入数据");
			return;
		}
		arr[rear]=n;//因为此时rear指向最后一个元素的后一个元素，所以先直接加入队列
		rear = (rear+1)%maxsize;//rear后移，但如果此时rear指向maxsize-1，加入一个数据后队列尾部已满
		//所以需要环形的指向队列中的第一个位置，因此这里rear要取模
	}
	
	//取出队列中的数据
	public int getQueue() {
		//先判断队列是否为空
		if(isEmpty()) {
			//通过抛出异常
			throw new RuntimeException("此时队列为空，不能取数据");
			//此时不需要再return   因为throw本身会直接导致代码return
		}
		//front是指向队列的第一个元素，我们需要先把front对应的值保存在一个变量中
//	             将front后移，接着将临时保存的变量返回
		int value = arr[front];
		front = (front+1)%maxsize;//有可能此时的队首为数组的最后一个元素，所以需要用到模
		return value;
	}
	
	//显示队列的所有数据
	public void showQueue() {
		//先判断是否为空
		if(isEmpty()) {
			sop("队列为空，没有数据");
			return;
		}
		//此时我们需要从front开始遍历
		for(int i=front;i<front+size();i++) {//对数组进行遍历
			System.out.printf("arr[%d]=%d\n",i%maxsize,arr[i%maxsize]);//进行格式化，打印出数组中的数据
			//此时下标应为i%maxsize,因为此时i的值可能大于maxsize
		}
	}
	
	//求出当前队列有效数据的个数
	public int size() {
		return (rear+maxsize-front)%maxsize;
	}
	
	//显示队列的头数据
	public int headQueue() {
		//判断队列是否为空
		if(isEmpty()) {
			throw new RuntimeException("此时队列为空，没有数据");
		}
		return arr[front];
	}
}

运行结果如下：