Java利用数组实现队列（二）——功能优化_循环数组

上一篇简单用数组实现了队列的功能，但是存在一点不足，就是数组不能达到复用的效果，所以这篇文章主要想说明下对数组实现队列的一个优化。

分析：
之前的数组，存在一个缺陷，就是当元素添加到数组满了之后，出队列却不能在继续添加了。所以，引入环形数组来解决这一问题

1. front：  之前是指向队列元素的前一个位置，现在指向队列的第一个元素。即之前arr[front+1]表示队头位置，现在arr[front]就表示对头位置，front的初始值是0。
2. rear:    之前是指向队列元素的最后一个位置，现在指向队列元素最后一个元素的后一个位置，因为要预留一个空间作为约定， rear的初始值为0。
3. 队列中有效数据的个数(rear+maxSize-front)%maxSize，因为rear的位置是不断变化的，有可能从数组的最后一个元素变成数组的第一个位置，这样计算得到的有效数据个数就是适应这种动态变化的。
4. 判断队列满：当(rear+1)%maxSize = front时，即队列满。
5. 判断队列空：当rear == front时，队列为空。

 其实队列满并非真正意义上的数组满了，总是会预留一个空间，这个空间是作为约定，判断环形队列的一个标志。

 

主要代码

package cn.mrlij.queue;

import java.util.Scanner;

/***
 * 利用数组实现环形队列
 * @author dreamer
 *
 */
public class CircleArrayQueue {

	/**
	 * 分析：
	 * 		之前的数组，存在一个缺陷，就是当元素添加到数组满了之后，出队列却不能在继续添加了
	 * 		所以，引入环形数组来解决这一问题
	 * 	front：  之前是指向队列元素的前一个位置，现在指向队列的第一个元素。
	 * 			即之前arr[front+1]表示队头位置，现在arr[front]就表示对头位置
	 * 			front的初始值是0
	 * 	rear:	之前是指向队列元素的最后一个位置，现在指向队列元素最后一个元素的后一个位置，
	 * 			因为要预留一个空间作为约定
	 * 			rear的初始值为0
	 * 	判断队列满：当(rear+1)%maxSize = front时，即队列满。
	 * 	判断队列空：当rear == front时，队列为空
	 * 
	 *	其实队列满并非真正意义上的数组满了，总是会预留一个空间，这个空间是作为约定，判断环形队列
	 *	的一个标志
	 * 
	 * 	队列中有效数据的个数(rear+maxSize-front)%maxSize，因为rear的位置是不断变化的，有可能从数组的最后
	 * 	一个元素变成数组的第一个位置来，这样计算得到的有效数据个数就是适应这种动态变化的。
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//创建一个长度为3的队列
		CircleQueue queue = new CircleQueue(4);
		boolean flag = true;
		while(flag){
			System.out.println("====================菜单==================");
			System.out.println("1：添加元素");
			System.out.println("2：显示所有元素");
			System.out.println("3：从队列取出元素");
			System.out.println("4：查看队头元素");
			System.out.println("5：退出");
			int r = sc.nextInt();
			switch(r) {
			case 1: 
				System.out.println("请输入要添加的元素");
				int nextInt = sc.nextInt();
				try {
					queue.add(nextInt);
				}catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 2:
				try {
					queue.show();
				}catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 3: 
					try {
						System.out.println(queue.pop());
					}catch (Exception e) {
						System.out.println(e.getMessage());
					}
					break;
			case 4: try {
						queue.showFront();
					} catch (Exception e) {
						System.out.println(e.getMessage());
					}
					break;
			case 5: System.out.println("结束");
					flag=false;
					break;
			default :flag=false;
				break;
			}
		}
	}
}
class CircleQueue {
	int maxSize; //队列的最大长度
	int front;	//队列的第一个元素，初始化为0
	int rear;	//队列最后一个元素的后一个位置，初始化为0
	int arr[];	//用于存储数据
	public CircleQueue(int size) {
		this.maxSize = size;
		arr = new int[size];
	}
	//判断队列是否满了
	public boolean isFull() {
		return (rear+1)%maxSize == front;
	}
	//判断是否是空队列
	public boolean isEmpty() {
		return front == rear;
	}
	//添加元素到队列
	public void add(int e) {
		if(isFull()) {
			System.out.println("队列已满，不能添加了。");
			return;
		}
		//添加一个元素，之前是rear++，现在是环形队列，必须考虑rear的位置到顶之后，会回到数组的
		//第一个位置
		arr[rear] = e;
		rear = (rear+1)%maxSize;
	}
	//取出元素
	public int pop() {
		if(isEmpty()) {
			throw new  RuntimeException("队列为空！");
		}
		//之前是front++，现在必须考虑front的位置到达顶部之后，会回到起始位置
		int value = front;
		front = (front+1)%maxSize;
		return arr[value];
	}
	//显示队列所有元素
	public void show() {
		if(isEmpty()) {
			throw new  RuntimeException("队列为空！");
		}
		//因为数据是可以不断变化的，就不能遍历数组了
		for(int i = front;i<front+size();i++ ) {
			System.out.println(arr[i]);
		}
	}
	//队列中有效数据的个数
	public int size() {
		return (rear+maxSize-front)%maxSize;
	}
	//显示队列队头元素
	public void showFront() {
		if(isEmpty()) {
			throw new RuntimeException("队列为空！");
		}
		System.out.println(arr[front]);
	}
}

如果有任何疑问的，请与我联系，谢谢！