Java数据结构与算法：循环队列

1. 思路与设计

对前面的数组模拟队列的优化，充分利用数组。因此将数组看做是一个环形的。(通过取模的方式来实现即可)
思路：

• front变量的含义做一个调整：front就指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素；front的初始值=0
• rear 变量的含义做一个调整：rear指向队列的最后一个元素，因为希望空出一个空间做为约定。rear的初始值=0
• 当队列满时，条件是：(rear+1)% maxSize = front
• 当队列空时，条件是：rear==front
• 队列中有效的数据的个数：(rear+maxSize-front)%maxSize

循环队列API设计：

使用方法	详细说明
public CircleArray(int arrMaxSize)	构造方法：初始化数据组最大值和存放队列数据
public boolean isFull()	判断队列是否满
public boolean isEmpty()	判断队列是否为空
public void addQueue(int n)	添加数据到队列
public int getQueue()	获取队列的数据，出队列
public void showQueue()	显示队列的所有数据
public int size()	求出当前队列有效数据的个数
public int headQueue()	显示队列的头数据，注意不是取出数据

2. 完整代码

public class CircleArrayQueueDemo {
	public static void main(String[] args) {
		// 说明设置4，其队列的有效数据最大是3
		CircleArray queue = new CircleArray(4);
		int key = 0;
		Scanner scanner = new Scanner(System.in);
		boolean loop = true;
		System.out.println("\t 1: 显示队列");
		System.out.println("\t 2: 添加数据到队列");
		System.out.println("\t 3: 从队列取出数据");
		System.out.println("\t 4: 查看队列头的数据");
		System.out.println("\t 5: 退出程序");
		while (loop) {
			key = scanner.nextInt();
			switch (key) {
			case 1:
				queue.showQueue();
				break;
			case 2:
				System.out.println(">>输入一个数：");
				int value = scanner.nextInt();
				queue.addQueue(value);
				break;
			case 3:
				try {
					int res = queue.getQueue();
					System.out.printf("取出的数据是%d\n", res);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 4:
				try {
					int res = queue.headQueue();
					System.out.printf("队列头的数据是%d\n", res);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case 5:
				scanner.close();
				loop = false;
				break;
			default:
				System.out.println("请输入有效数字~");
				break;
			}
		}
		System.out.println("程序退出~");
	}
}
//核心实现代码
class CircleArray {
	private int maxSize;// 表示数组的最大值
	// front 变量的含义做一个调整： front 就指向队列的第一个元素,
	// 也就是说 arr[front] 就是队列的第一个元素
	// front 的初始值 = 0
	private int front; // 队列头
	// rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置.
	// 因为希望空出一个空间做为约定
	// rear 的初始值 = 0
	private int rear; // 队列尾
	private int[] arr; // 该数据用于存放数据, 模拟队列

	public CircleArray(int arrMaxSize) {
		maxSize = arrMaxSize;
		arr = new int[maxSize];
	}

	// 判断队列是否满
	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;
		}
		// 直接插入数据
		arr[rear] = n;
		// 将rear 后移，这里必须考虑取模
		rear = (rear + 1) % maxSize;
		System.out.println(">>输出成功！");
	}

	// 获取队列的数据，出队列
	public int getQueue() {
		if (isEmpty()) {
			throw new RuntimeException("队列空，不能取数据");
		}
		int value = arr[front];
		front = (front + 1) % maxSize;
		return value;
	}

	// 显示队列的所有数据
	public void showQueue() {
		if (isEmpty()) {
			System.out.println("队列空的，没有数据~");
			return;
		}
		for (int i = front; i < front + size(); i++) {
			System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
		}
	}

	// 求出当前队列有效数据的个数
	public int size() {
		return (rear + maxSize - front) % maxSize;
	}

	// 显示队列的头数据，注意不是取出数据
	public int headQueue() {
		if (isEmpty()) {
			throw new RuntimeException("队列空的，没有数据~");
		}
		return arr[front];
	}

}

3. LeetCode_662设计循环队列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/design-circular-queue

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

实现代码：

class MyCircularQueue {
    /**此方法并没有牺牲一个额外空间，整个数组的内存分配均可使用 */
    private int front;   //队列头
    private int rear;    //队列尾
    private int maxSize; //队列最大数
    private int[] data;  //队列存放的数据

    public MyCircularQueue(int k) {
        maxSize=k;
        data=new int[maxSize];
        front=-1;
        rear=-1;
    }
    
    public boolean enQueue(int value) {
        if(isFull()){
            return false;
        }
        if(isEmpty()){
            front=0;
        }
        rear=(rear+1)%maxSize;
        data[rear]=value;
        return true;
    }
    
    public boolean deQueue() {
        if(isEmpty()){
            return false;
        }
        if(front==rear){
            front=-1;
            rear=-1;
        }else{
            front=(front+1)%maxSize;
        }
        return true;
    }
    
    public int Front() {
        if(isEmpty()){
            return -1;
        }
        return data[front];
    }
    
    public int Rear() {
        if(isEmpty()){
            return -1;
        }
        return data[rear];
    }
    
    public boolean isEmpty() {
        return front==-1;
    }
    
    public boolean isFull() {
        return (rear+1)%maxSize==front;
    }
}