两种思路的环形数组队列

方法一：

front 指向队列的第一个元素，

rear 指向队列的最后一个元素的后一个位置，因为希望空出一个空间做为约定.

当前队列有效数据的个数(rear + maxSize - front) % maxSize

class CircleArray {
	private int maxSize; // 表示数组的最大容量
	//front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
	//front 的初始值 = 0
	private int front;
	//rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
	//rear 的初始值 = 0
	private int rear; // 队列尾
	private int[] arr; // 该数据用于存放数据, 模拟队列

	public CircleArray(int arrMaxSize) {
		maxSize = arrMaxSize;
		arr = new int[maxSize];
	}

	// 判断队列是否满
	public boolean isFull() {
		return (rear  + 1) % maxSize == front;
	}

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

	// 添加数据到队列
	public void addQueue(int n) {
		// 判断队列是否满
		if (isFull()) {
			System.out.println("队列满，不能加入数据~");
			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("队列空的，没有数据~~");
			return;
		}
		// 思路：从front开始遍历，遍历多少个元素
		// 动脑筋
		for (int i = front; i < front + size() ; i++) {
			System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
		}
	}

	// 求出当前队列有效数据的个数
	public int size() {
		// rear = 2
		// front = 1
		// maxSize = 3
		return (rear + maxSize - front) % maxSize;
	}

	// 显示队列的头数据， 注意不是取出数据
	public int headQueue() {
		// 判断
		if (isEmpty()) {
			throw new RuntimeException("队列空的，没有数据~~");
		}
		return arr[front];
	}
}

 

存在的问题：
   假设数组的容量为4，当front==0.数据存在索引为1处，此时rear==3，此时
   根据判断条件：  (rear  + 1) % maxSize == front，数组已满。但是现在数组明显
   还有一块索引为3的空间没有存储数据，即浪费空间。
   即索引为maxSize 的位置空间无法存储元素
   开始存储：arr[0]=10;arr[1]=20;arr[2]=30，此时无法在arr[3]中存储数据，提示队列已满
  取出arr[0]元素后： arr[1]=20;arr[2]=30;arr[3]=40

 方法一始终有一块空间未存储

 方法二：

front 指向队列的第一个元素，

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

当前队列有效数据的个数(rear+maxSize-front)%maxSize+1

 class CircleArry {
        private int[] arr;//用于存放数据
        private int maxSize;//最大容量
        private int front;
        //front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
        //front 的初始值 = 0
        private int rear;
        //rear 变量的含义做一个调整：rear 指向队列的最后一个元素的位置.
        //rear 的初始值 = 0

        //队列构造器
        public CircleArry(int arrMaxSize) {
            maxSize = arrMaxSize;//最大容量
            arr = new int[maxSize];//数组初始化
            //此处front和rear不作初始化也可，因为成员变量会默认初始化
            front = 0;//指向队列头数据
            rear = 0;//指向队列尾数据
        }

        //判断队列是否满了
        public boolean isFull() {
            return (rear + 1) % maxSize == front;
        }

        //判读队列是否为空
        public boolean isEmpty() {
            return rear== front;
        }

        //添加数据到队列
        public void addQueue(int n) {
            //判断队列是否满了
            if (isFull()) {
                //满了
                System.out.println("队列满了，无法添加数据。");
                return;
            }
            //没满,存储数据
            rear=(++rear%maxSize);//让rear后移
            arr[rear] = n;
            /**
             * 当数据为空时，rear==0，front==0；存储数据会跳过索引为0的位置，
             * 此时在数据不取出的情况下。最多只能存储maxSize-1个数据
             */
        }

        //获取队列数据，出队列
        public int getQueue(){
            //判断队列是否为空
            if (isEmpty()){
                //队列为空
                throw new RuntimeException("队列空，无法获取数据。");
            }
            //队列不为空
            int value = arr[front];
            front=(++front%maxSize);//让front后移
            return value;
        }

        //显式队列的有效数据
        public int size(){
            return (rear+maxSize-front)%maxSize+1;
        }

        //显式队列的所有数据
        public void showQueue(){
            //判断队列是否为空
            if (isEmpty()){
                //队列为空
                System.out.println("队列为空，无法展示数据。");
                return;
            }
            //队列不为空
            //遍历
            for (int i = front; i <front+size(); i++) {
                System.out.printf("arr[%d]=%d\n",i%maxSize,arr[i%maxSize]);
            }
        }

        //显式队列的头数据，注意不是取出数据
        public int headQueue(){
            //判断队列是否为空
            if (isEmpty()){
                //队列为空
                throw new RuntimeException("队列为空,队列头无数据。");
            }
            //队列不为空
            return arr[front];
        }


    }

 

存在的问题：
        当数据为空时，rear==0，front==0；存储数据会跳过索引为0的位置，
        此时在数据不取出的情况下。最多只能存储maxSize-1个数据。
        即开始时索引为0的位置空间无法存储元素，必须取出索引为0的元素才能存储
           开始存储： arr[0]=0;arr[1]=10;arr[2]=20;arr[3]=30
           取出元素后： arr[1]=10;arr[2]=20;arr[3]=30;arr[0]=40

 方法二中arr[0]初始值为0，开始时从arr[1]开始存储数据。当arr[0]中的是数据被取出后，才能在arr[0]存储数据。

说明

方法一是b站韩顺平老师的视频的源码；方法二是个人理解。

方法二存在的问题还希望大佬能够批评指正。谢谢啦(*^▽^*)