数组模拟环形队列

 在数组模拟队列的基础上，通过取模达到环形来实现

分析思路：
 1.front变量的含义做一个调整：front指向队列的第一个元素，即front初始值为0,arr[front]即为第一个元素

 2.rear变量的含义做一个调整:rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定，rear的初始值为0

 3.此时，队列满的条件为：（rear+1）%maxsize=front

 4.队列为空的条件为： rear=front

 5.队列中有效数据个数为（rear+maxsize-front）%maxsize

实现代码

package com.atxihua;



import java.util.Scanner;

public class CircleArryQueueDemo {
        public static void main(String[] args) {
            //进行简单的测试
            System.out.println("测试数组模拟环形队列");
            //创建一个环形队列
            CircleArrayQueue queue=new CircleArrayQueue(4);//设置为4，实际有效长度为3，做了一个额外的空间约定
            //接受用户输入，注意''之间有空格
            char key = ' ';
            //键盘输入
            Scanner scanner=new Scanner(System.in);
            //声明一个boolean类型的loop,控制循环
            boolean loop=true;
            //简单输出一个菜单便于提示操作
            while (loop){
                System.out.println("s(show): 显示队列");
                System.out.println("e(exit): 退出程序");
                System.out.println("a(add): 添加数据到队列");
                System.out.println("g(get): 从队列取出数据");
                System.out.println("h(head): 查看队列头的数据");
                //接受一个字符
                key=scanner.next().charAt(0);
                switch (key){
                    case 's':
                        queue.showQueue();
                        break;
                    case 'a':
                        System.out.println("输入一个数");
                        int value=scanner.nextInt();
                        queue.addQueue(value);
                        break;
                    case 'g':
                        try {
                            int res = queue.getQueue();
                            System.out.println("取出的数据是："+ res);
                        } catch (Exception e) {
                            // TODO: handle exception
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'h': //查看队列头的数据
                        try {
                            int res = queue.headQueue();
                            System.out.println("队列头的数据是:"+res);
                        } catch (Exception e) {
                            // TODO: handle exception
                            System.out.println(e.getMessage());
                        }
                        break;
                    case 'e': //退出
                        scanner.close();
                        loop = false;
                        break;
                    default:
                        break;
                }
            }
            System.out.println("程序退出~~");
        }
    }
    class  CircleArrayQueue{
        //表示数组的最大容量
        private int maxSize;
        //front变量的含义做一个调整：front就指向队列的第一个元素
        //front的初始值=0
        private  int front;
        //rear变量的含义做一个调整:rear指向队列的最后一个元素的后一个位置
        //rear的初始值=0
        private  int rear;
        //该数组用于存放数据，模拟队列
        private int[] arr;
        //创建队列的构造器，传递最大容量的值
        public  CircleArrayQueue(int arrMaxSiza){
            maxSize=arrMaxSiza;
            arr=new int[maxSize];
            //指向队列头部，分析出front是指向队列头的前一个位置.
            front=0;
            //front和rear声明为int型，初始值为0可以不写
            rear=0;
        }
        //判断队列是否已满
        public boolean isFull(){
            //当队列尾部与(rear+1)%maxSize==front相等时，说明队列已满
            return  (rear+1)%maxSize==front;
        }
        //判断队列是否为空
        public  boolean isEmpty(){
            //当队列头与队列尾相等时，说明队列中没有数据
            return  rear==front;
        }
        //添加数据到队列中
        public  void addQueue(int n){
            //判断队列是否已满
            if(isFull()){
                System.out.println("队列已满，不能加入数据!!!");
　　　　　　　　　　//这里一定要return退出，不然后面环形队列展示执行了后续代码会显示队列为空
　　　　　　　　　　return;
            }
            //直接将数据加入
            arr[rear]=n;
            //将rear后移，环形队列这里必须考虑取模
            rear=(rear+1)%maxSize;

        }
        //获取队列的数据，出队列
        public int getQueue(){
            //判断队列是否为空
            if(isEmpty()){
                //抛出自定义异常
                throw  new RuntimeException("队列为空，没有数据可取！！！");
            }
          //这里需要分析出front是指向队列的第一个元素
          //1.先把front对应的值保留到一个临时变量
          //2.将front后移，环形队列考虑取模,否则会越界
          //3.将临时保存的变量返回
            int value=arr[front];
            front=(front+1)%maxSize;
            return value;
        }
        //显示队列所有数据
        public  void showQueue(){
            //判断队列是否为空
            if(isEmpty()){
                //这里可以写成System.out.println()提示队列为空就行
                System.out.println("队列为空，没有数据可取！！！");
            }
            //遍历有效长度，从头指针到元素个数次
            for(int i=front;i<front+size();i++){
                //System.out.println(arr[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("队列为空，没有数据可取！！！");
            }
            //注意front初始值为0，指向队列第一个元素
            return arr[front];
        }

    }

 效果展示：

 总结：数组模拟环形队列的情况，只是在数组模拟队列的情况下通过取模来控制队列循环，约定了一个空间做为约定（也可以不约定，只是改变判空和判满的条件来实现）。