数据结构与算法（Java版）_04_环形队列

虽然在数据结构与算法（Java版）_03_队列时已经对队列这种数据结构进行了简单的模拟，

但是这个模拟的小demo还是存在一些问题，就是这种方式模拟的队列只能使用一次。

那么如何解决这个问题呢，可以使用环形队列来解决这个问题。

优化方案：

font指向第一个元素;

rear指向最后一个元素的后一个位置 

初始值：

front = 0;

rear = 0;

判断队列满的条件为：(rear + 1) % maxSize == front;

队列添加元素指针rear的移动方式：rear = (rear+1) % maxSize;

元素出列指针front移动方式：front = (front+1) % maxSize;

判断队列为空的条件：rear == front;

队列中有效数据个数：(rear + maxSize - front) % maxSize;

图示分析：

代码实现：

package dataStructureAtShangGuiGu;

import java.util.Scanner;

public class CircleQueueDemo {

    public static void main(String[] args) {
        CircleQueueTest queue = new CircleQueueTest(4);
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while(loop) {
            sopInfo();
            char ch = scanner.next().charAt(0);
            switch(ch){
                case 'a':
                    System.out.println("请输入：");
                    queue.add(scanner.nextInt());
                    break;
                case 'g':
                    queue.get();
                    break;
                case 'h':
                    queue.showHead();
                    break;
                case 's':
                    queue.show();
                    break;
                case 'e':
                    loop = false;
                    scanner.close();
                    break;
                    
            }
        }

    }
    private static void sopInfo() {
        System.out.println("--------------------------");
        System.out.println("a(add)添加元素");
        System.out.println("g(get)获取元素");
        System.out.println("h(head)查看第一个元素");
        System.out.println("s(show)查看所有元素");
        System.out.println("e(exit)退出");
        System.out.println("--------------------------");
    }
    
}
class CircleQueueTest{
    private int maxSize; //队列最大容量
    private int front; //队列头指针
    private int rear; //队列尾指针
    private int[] arr; //模拟队列容器
    CircleQueueTest(int maxSize){
        this.maxSize = maxSize;
        this.arr = new int[maxSize];
    }
    private boolean isEmpty() { //判断队列是否空
        return this.front == this.rear;
    }
    private boolean isFull() { //判断队列是否满了
        return this.front == (this.rear+1) % this.maxSize;
    }
    public void add(int num) { //向队列加入元素
        if(this.isFull()) {
            System.err.println("队列已满！");
            return;
        }
        this.arr[this.rear] = num;
        this.rear = (this.rear+1) % this.maxSize;
    }
    public void get() { //获取元素，出队列
        if(this.isEmpty()) {
            System.err.println("队列为空！");
            return;
        }
        int tmp = this.arr[this.front];
        this.front = (this.front+1) % this.maxSize;
        System.out.println(tmp);
    }
    public void show() { //打印队列
        if(this.isEmpty()) {
            System.err.println("队列为空！");
            return;
        }
        for(int i=this.front;i<(front+this.size());i++) {
            System.out.printf("arr[%d]=%d
",i%this.maxSize,this.arr[i%this.maxSize]);
        }
    }
    public void showHead() {
        if(this.isEmpty()) {
            System.err.println("队列为空！");
            return;
        }
        int tmp = this.arr[this.front];
        System.out.println(tmp);
    }
    private int size() { //获取队列有效元素个数
        return (this.rear+this.maxSize-front) % this.maxSize;
    }
}

运行测试：

先添加元素：

 先取一个元素，然后打印队列看看：

 把元素全取出来，然后添加查看队列：

 结论：环形队列可以无限次使用。