数组模拟环形队列思路

基本思路：

1. front变量的含义做一个调整：front就指向队列的第一个元素，也就是说arr[front]就是指队列的第一个元素。front初始值=0

2. rear变量的含义做一个调整：rear指向队列的最后一个元素的后一个位置，因为希望空一个空间作为约定，rear初始值=0

3. 队列满的条件：（rear+1）%maxsize = front

4. 队列空的情况：rear == front

5. 队列中元素数据个数是：（rear + maxsize - front）%maxsize

6. 队列中的有效存储位是maxsize -1 。因为约定预留一个空间

关于环形队列代码列出与普通队列不同点：

第一：

rear = front =0；
定义就是都为0。

第二：判断队列是否满了

之前代码：

// 判断队列是否满了
	public boolean isFull() {
		return rear == maxsize - 1;
	}

环形代码：

// 判断队列是否满了
	public boolean isFull() {
		return (rear + 1) % maxsize == front;
	}

第三：添加数据到队列

普通队列：

	// 添加数据到队列
	public void addQueue(int n) {
		// 先判断队列是否满了
		if (isFull()) {
			System.out.println("队列已经满了，加入不了数据！");
			return;
		}
		rear++; // 让rear后移
		arry[rear] = n;
	}

环形队列：

// 添加数据到队列
	public void addQueue(int n) {
		// 先判断队列是否满了
		if (isFull()) {
			System.out.println("队列已经满了，加入不了数据！");
			return;
		}
		// rear++; // 让rear后移，这里不需要先加一，因为rear本身指的是元素的后一位
		array[rear] = n;
		// 将rear后移，这里必须考虑取模,直接加1，数组有可能越界，取模直接循环
		rear = (rear + 1) % maxsize;
	}

rear本身后面就有空间，直接加入数据就行，不需要先加1，再加数据。
rear加了1后，要判断是否越界，则用取模的方式处理

第四：取出数据，出队列
普通队列：

// 获取队列中的数据，出队列
	public int getQueue() {
		// 判断队列是否为空
		if (isEmpty()) {
			throw new RuntimeException("队列为空，不能取数据！");// 不必返回return，throw代码已经返回
		}
		front++;// 后移
		return arry[front];
	}

环形队列：

// 获取队列中的数据，出队列
	public int getQueue() {
		// 判断队列是否为空
		if (isEmpty()) {
			throw new RuntimeException("队列为空，不能取数据！");// 不必返回return，throw代码已经返回
		}
		// front++;// 
		//这里需要分析出front是指向队列的第一个元素
		/*
		 *  1.先将front 对应的值保留到一个临时变量
		 *  2.将front后移,考虑取模
		 *  3.将临时变量保存的值返回
		 */
		int temp = array[front];
		front = (front+1)%maxsize; 
		return temp;

	}

这里为什么要使用临时变量呢？因为如果你直接返回front下标的队列的值，然后再对front进行+1操作。return后面的语句是无法执行的。因为已经return了，后面语句直接跳过。

第四：显示队列的所有数据

普通队列：

// 显示队列的所有数据
	public void showQueue() {
		if (isEmpty()) {
			System.out.println("队列为空，没有数据打印！");
			return;
		}
		for (int i = 0; i < arry.length; i++) {
			System.out.printf("arry[%d]=%d\n", i, arry[i]);
		}
	}

环形队列：

// 显示队列的所有数据
	public void showQueue() {
		if (isEmpty()) {
			System.out.println("队列为空，没有数据打印！");
			return;
		}
		//for (int i = 0; i < array.length; i++) {
			//System.out.printf("array[%d]=%d\n", i, array[i]);
		//}
		/*
		 * 思路：从front开始遍历，遍历多少个元素
		 */
		
		
		for(int i = front; i < front + size();i++) {
			System.out.printf("array[%d]=%d\n", i % maxsize, array[i % maxsize]);//下标也需要改
		}
	}
	public int size() {
		return  (rear + maxsize - front)%maxsize;//有效数据个数
	}

先确定环形队列中有多少个有效的数据，然后从front开始遍历，front在加一的时候有可能数组越界，则需对其取模

第五：显示头部数据

环形队列：

	// 显示队列的头部数据
	public int headQueue() {
		if (isEmpty()) {
			throw new RuntimeException("队列为空，没有数据打印！");
		}

		return array[front];//返回不需要加1了

	}

再附上源码：

package com.suanfa;

import java.util.Scanner;

public class CircleArrayQueueDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CircleArry arrayQueue = new CircleArry(4);//数据个数最大为3
		char key = ' ';// 接收用戶輸入
		Scanner scanner = new Scanner(System.in);
		boolean loop = true;
		while (loop) {
			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):查看队列头的数据");
			key = scanner.next().charAt(0);
			switch (key) {
			case 's':
				arrayQueue.showQueue();
				break;
			case 'a':
				System.out.println("请输入一个数字");
				int value = scanner.nextInt();
				arrayQueue.addQueue(value);
				;
				break;
			case 'g':
				try {
					int res = arrayQueue.getQueue();
					System.out.printf("取出的数据是%d", res);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}

				break;
			case 'h':
				try {
					int res = arrayQueue.headQueue();
					System.out.printf("取出队列头数据是%d", res);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case 'e':
				scanner.close();
				loop = false;
				break;

			}
		}
		System.out.println("程序退出");

	}

}

class CircleArry {
	private int maxsize;// 表示数组的最大容量
	private int front;// 表示数组的头部：front就指向队列的第一个元素，也就是说arr[front]就是指队列的第一个元素。front初始值=0
	private int rear;// 表示数组的尾部rear指向队列的最后一个元素的后一个位置，因为希望空一个空间作为约定，rear初始值=0
	private int[] array;// 该数组用于存储数据，模拟队列

	public CircleArry(int arrMaxsize) {
		maxsize = arrMaxsize;
		array = new int[maxsize];
		front = 0;
		rear = 0;
	}

	// 判断队列是否满了
	public boolean isFull() {
		return (rear + 1) % maxsize == front;
	}

	// 判断队列是否为空
	public boolean isEmpty() {
		return rear == front;
	}

	// 添加数据到队列
	public void addQueue(int n) {
		// 先判断队列是否满了
		if (isFull()) {
			System.out.println("队列已经满了，加入不了数据！");
			return;
		}
		// rear++; // 让rear后移，这里不需要先加一，因为rear本身指的是元素的后一位
		array[rear] = n;
		// 将rear后移，这里必须考虑取模,直接加1，数组有可能越界，取模直接循环
		rear = (rear + 1) % maxsize;
	}

	// 获取队列中的数据，出队列
	public int getQueue() {
		// 判断队列是否为空
		if (isEmpty()) {
			throw new RuntimeException("队列为空，不能取数据！");// 不必返回return，throw代码已经返回
		}
		// front++;//
		// 这里需要分析出front是指向队列的第一个元素
		/*
		 * 1.先将front 对应的值保留到一个临时变量 2.将front后移,考虑取模 3.将临时变量保存的值返回
		 */
		int temp = array[front];
		front = (front + 1) % maxsize;
		return temp;

	}

	// 显示队列的所有数据
	public void showQueue() {
		if (isEmpty()) {
			System.out.println("队列为空，没有数据打印！");
			return;
		}
		// for (int i = 0; i < array.length; i++) {
		// System.out.printf("array[%d]=%d\n", i, array[i]);
		// }
		/*
		 * 思路：从front开始遍历，遍历多少个元素
		 */

		for (int i = front; i < front + size(); i++) {
			System.out.printf("array[%d]=%d\n", i % maxsize, array[i % maxsize]);// 下标也需要改
		}
	}

	public int size() {
		return (rear + maxsize - front) % maxsize;// 有效数据个数
	}

	// 显示队列的头部数据
	public int headQueue() {
		if (isEmpty()) {
			throw new RuntimeException("队列为空，没有数据打印！");
		}

		return array[front];// 返回不需要加1了

	}

}