数组模拟环形队列

class  queue{
    //我么假设队列实际上就是一个容器 ， 把他想象成一个杯子
    //既然是容器，那么我们得设置最大值和最小值
    private  int   maxsize; //队列的最大值(the maximum of queue)

    private  int   rear   ; //队列的 尾部 (the minimum of queue)  队列的尾部 是用来 加队列的  每加一个数据 队列尾部就上升一格

    private  int   front  ; //队列的头部   队列的头部  是用来出队列的  为了保持 有个指针 指向尾部  方便取数据

    private  int[] arr    ;//队列的容器 （ the container of queue)

    /**
     *  需要从外部给容器队列设置最大值
     *  初始化容器
     * @param maxsize
     */
    public  queue(int  maxsize){
        this.maxsize=maxsize;

        arr=new  int[maxsize];
        front=0;  //给容器头部 设置初始值 为0   , 他控制着数组的 获取
        rear =0;  //给容器尾部 设置初始值 为0   ，他控制着数组的 添加
    }

    /**
     * 判断队列是否满
     */
    public  boolean  isFull(){
        /*
            随着添加的数据的数量达到最大值(rear+1) 与 数组 的 最大值(maxsize) 比较
            如果相等 rear+1 = maxsize;
            则maxsize % maxsize = 0 ; 重新排列
            给数组预留一个空间
            列如
            当 rear =  7 ，maxsize= 8 ,front = 1  时
            则他的过程就是 ( 7 + 1 ) % 8 = 0;
            rear == 0 ;
            rear +  1  = front;
            所以 rear = 0  front =1 ; 预留一个位置
         */
       return (rear+1)%maxsize==front;
    }

    /**
     * 判断队列是否为空
     */
    public boolean  isEmpty(){
        /*
          当添加的数据的数量等于获取的数据
         */
        return  rear==front;
    }

    /**
     * 添加数据
     * @param n  添加数据的值
     */
    public  void  addQueue(int  n){
        if (isFull()){
            System.out.println("队列满");
          return;
        }
        arr[rear]=n;
        /**
         * 注意 这里一定要 去摸（%） 而且 注意 rear 要加 1
         */
        rear =  (rear+1) %  maxsize;

    }
    /**
     * 取出数据
     */
    public  int   getQueue(){
        if (isEmpty()){
            throw  new  RuntimeException("队列空，不能取出数据");
        }
        /*
         这里我们 应该 考虑 俩个问题
           第一  头指针(front) 应该 是增加 并且 达到 最高峰的 时候
           返回到 初始位置 达到一种循环状态
           第二· 是 先增加 还是  先返回
         */
         int value = arr[front]; //保存当前数据，应该先返回 后增加 但是返回(return)后面不能写代码，所以先保存当先数据 ，再增加
        front =  (front+1) %  maxsize;
        return  value;
    }

    /**
     * 显示队列中的数据
     */
    public  void  showQueue(){
       if (isEmpty()){
           return;
       }
       /*
        注意这里 % maxsize
        */
        for (int i = front; i < front+size(); i++) {
            System.out.printf("arr[%d]=%d\n",i%maxsize,arr[i%maxsize]);
        }
    }

    /**
     * 得到队列的有效数据
     * @return
     */
    private int  size(){
        /**
         * 实际上队列 的 有效数据 是 添加的值(rear)减去获取的值(front) rear - front
         * 比如说  添加了10个数据  获取了 3 个数据
         * 队列的有效数据 10-3
         * 但是为了防止数据 得到负数
         * 比如说  rear = 2  front = 9
         * 2 -7 =-5
         * 所以 要加上一个 maxsize
         * 所以有效数据为 -5 + 10 = 5 ；
         * 因为是环形 得 % maxsize
         * 公式变形为  (rear-front)% maxsize +maxsize % maxsize =(rear-front)% maxsize  +0
         */
        return ( rear - front + maxsize) %  maxsize ;
    }
    //显示队列的头部
    public  int  getHand(){
        if (isEmpty()){
            throw new RuntimeException("队列为空，无法取出数据");
        }
        //显示头数据
        return arr[front];

    }
}