循环数组实现队列以及算法分析

/*
*   使用数组实现循环队列
*/
public class ArrarImplyQueue {
    //底层数组
    private Object[] arr;
    //用于指向队列头部
    private int front;
    //用于指向队列尾部
    private int tail;

    //数组的默认大小为10
    public ArrarImplyQueue(){
        this(10);
    }

    //使用自定义大小
    public ArrarImplyQueue(int size){
        arr = new Object[size];
        front = 0;
        tail = 0;
    }

    // 判断是否满队列
    public boolean isFull(){
        return (tail+1)%arr.length == front;
    }

    //进入队列
    public boolean add(Object obj){
      //当队列的对头索引值和队尾索引值相等时返回false
        if(isFull()){
            return false;
        }
        arr[tail] = obj;
        //如果下标索引超出数组的长度则从数组的起始位置重新开始
        tail = (tail+1)%arr.length;
        return true;
    }

    //出队列
    public Object remove(){
      //如果下标索引超出数组的长度则返回null 
      if (front == tail){
            return null;
        }
        //即将出队列的值保存到临时变量obj中
        Object obj =  arr[front];
        //数据出队列将下标索引值移动
        front = (front+1)%arr.length;
        return obj;
    }

    public static void main(String[] args) {
        ArrarImplyQueue queue = new ArrarImplyQueue();
        queue.add("第一");
        queue.add("第二");
        System.out.println(queue.remove());
        System.out.println(queue.remove());
    }
}
    

  不成熟小想法：对满队列判断公式 (tail+1)%arr.length == front; 的说明

情况分析：
一、当尾元素在后，头元素在前，且满队列时，只有tail=9,front=0一种情况，公式（9+1）%10 == 0，成立。
　　这种情况可以用通用算法：tail+1-front==arr.length，
　　即(tail+1)-arr.length==front，front必然为0 
　　-》(tail+1)-arr.length=0 
　　-》(tail+1)=arr.length 
　　-》(tail+1)%arr.length == 0

二、当尾元素在前，头元素在后，且满队列时，有多种情况，例如tail=4,front=5时，公式（4+1）%10 == 5，成立。
　　这种情况，因为（tail+1）必然小于arr.length,因此取模结果必然等于（tail+1）自身，所以不做取模操作也成立。

将以上两种情况进行算法统一，即： (tail+1)%arr.length == front;