环形队列（Java实现）

环形队列（Java实现）

基本概念

1. 队列是有序的线性结构，可用顺序表（即数组）实现
2. 队列满足先进先出，即从尾部 rear 加入，从头部 front 弹出
3. 队列容量记为 maxSize，表示数量，是一个物理逻辑
4. 普通队列和环形队列的比较

普通队列和环形队列的比较

1. 普通队列每取出一个元素，头指针 rear 只能往后移动，则顺序表（数组）前面的位置无法重复使用，造成资源浪费。
2. 同时，若尾指针指向队列最后，当首尾指针重合时，说明队列为空，由于无法重复使用前面位置，因此该队列报废。

环形队列实现方式

1. 数据从尾部加入，尾指针加1；从头部取出，头指针加1

2. 环形，是逻辑上的环形，即当指针超出顺序表长度（maxSize-1）时，指针就重新从0开始 （前提是还没满）

3. 头/尾指针的初值均为0 {变化}：
   ① front 指向队列已有的第1个元素
   ② rear 指向队列现有最后1个元素的后一个 （这里理解为，队列有效个数只能为最大容量-1，队列的最后1个元素永远是空，即 rear 指向的这个）

    注1：rear 这么设置有1个好处，就是正常逻辑下，rear - front 就是队列的有效个数
    注2：可以直接将 rear 当成指向最后1个元素，只是这个元素是空、无效的，这样逻辑计算才不会出错
   

4. 队列达到最大容量的条件：(rear+1)%maxSize == front

   注3：队列已满是指，整个顺序表的所有内存位置都放满元素，两种情况：
   	1）rear > front，且front=0，说明rear还没进入下个循环，且头指针也没动，那rear等于
   	  "最大容量-1"，就是满了 
   	2）rear < front，说明rear已经进入下个循环，那就必须是rear和front之间没有位置，就是满了，
   	   具体是rear在front前1位
   注4：对条件剖析，式中（rear+1）指必须从下一位来判断是否已满(下一位重合才是满队列)，
   	1）对容量取模，显然第1种情况满足；
   	2）对于第2种情况，左边的取模结果，就刚好是当前rear的下一位，只要等于front，那就是循环1圈
   	   的rear+1与front重合了，他们之间没位置了，那肯定满了
   

5. 队列当前有效元素个数：(rear+maxSize-front)%maxSize

   注5：若没有循环，那 rear-front 就是有效个数，但若是考虑循环，即 rear < front，像时钟一样，
       那（rear+maxSize）即体现它应有的大小，再作差
   注6：对条件剖析，式中取模，就是兼顾已/未进入循环两种情况，若还没进入下个循环，那就是多加上一个maxSize，那取模就是将它舍去
   

6. 判断队列为空：front == rear

   注7：条件不变，只是理解有点不同，front指向现有第1个元素，rear指向空，若重合，说明队列为空
   

7. 头/尾指针移动的循环变换：(rear+1) % maxSize 、(front+1) % maxSize

   注8：这里就不用想太复杂。首尾指针往后移，就加1；当超过队列长度，模上长度，就又从头开始 （maxSize就是队列长度，指针从0计数，模上长度，也是从0计数）
   

强度：maxSize 只是个数量，队列从0开始计数，模上1个数量，还是从0计数，并不涉及物理/计算机逻辑转换

// java
/*环形队列类*/
class CircleQueue<T>{
    private int maxSize;  // 最大容量
    private int front;    // 头指针
    private int rear;     // 尾指针
    private T[] arr;      // 顺序表

    CircleQueue(){}

    CircleQueue(int maxSize){
        this.maxSize = maxSize;
        arr = (T[])new Object[maxSize];
    }

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

    // 2.判断队列是否已满
    private boolean isFull(){
        return (rear+1) % maxSize == front;
    }
    
    // 3.添加元素
    public void addQueue(T n){
        // 3.1 判断是否已满
        if(isFull()){
            System.out.println("添加失败，队列已满！");
        }else{
            // 3.2 加入 <= 先加后移
            arr[rear] = n;
            rear = (rear+1) % maxSize;  //<= rear+1即超过队列长度，模上长度，就又从头开始
            System.out.println("添加成功！");
        }
    }

    // 4.取出元素
    public T getQueue(){
        // 4.1 判断是否为空
        if(isEmpty()){
            throw new RuntimeException("获取失败，队列为空！");
        }
        // 4.2 取出 <= 先取再移，最后返回
        T val = arr[front];
        front = (front+1) % maxSize;
        return val;
    }

    // 5.查看现有第1个元素
    public void Peek(){
        if(isEmpty()){
            System.out.println("获取失败，队列为空!");
        }else{
            System.out.println(arr[front]);
        }
    }

    // 6.查看所有元素
    public void show(){
        if(isEmpty()){
            System.out.println("获取失败，队列为空!");
        }else{
            for(int i=front; i<front + Size(); i++){
                System.out.println("[" + (i % maxSize) + "] -- " 
                                   + arr[(i % maxSize)]);
            }
        }
    }

    // 获取有效长度  <= 已经保证不为空
    private int Size(){
        return (rear + maxSize - front) % maxSize;
    }
}