[数据结构]-数组实现环形队列之关键

主要思路

实现队列类
主要属性包括：存储数据的数组arr[],数组的大小maxSize，队首指针front,队尾指针rear;
主要方法包括：判断队列是否为空，判断队列是否已满，入队操作，出队操作，获得队首元素，获得队列存储的元素数量，遍历队列所有的元素。

属性说明

1、maxSize：最多可以存储的数据量；
2、front：队首指针，默认值为0，出队时使用；
3、rear：队尾指针，默认值为0，入队时使用；
4、arr[]：用于存储队列元素的数组

成员方法说明

1、isEmpty()：判断队列是否为空，判断条件为 front==rear

public boolean isEmpty(){
        return this.front == this.rear;
    }

2、isFull()：判断队列是否已满，判断条件为
（rear+1）%maxSize==front

public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }

3、addQueue()：入队操作，首先判断是否已满，然后入队

public void addQueue(int value){
        if(isFull()){
            System.out.println("queue is full.");
            return;
        }
        arr[rear] = value;
        rear = (rear + 1) % maxSize;
    }

4、delQueue()：出队操作，首先判断是否为空，然后出队

public int delQueue(){
        if(isEmpty()){
            throw new RuntimeException("queue is empty.");
        }
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }

5、size()：获得当前队列中元素的个数

public int size(){
        return (rear - front + maxSize) % maxSize;
    }

6、show()：遍历输出当前队列的所有元素

public void show(){
        if(isEmpty()){
            System.out.println("queue is empty");
            return;
        }
        for(int i = front; i < front + size(); i++){
            System.out.printf("arr[%d] = %d\n", i % maxSize, arr[i%maxSize]);
        }
    }

7、getHead()：获得当前队列的队头元素

public int getHead(){
        if(isEmpty()){
            throw new RuntimeException("queue is empty.");
        }
        return arr[front];
    }

完整代码

import java.io.*;
class queue  
{
    
    private int maxSize;
    private int front = 0; 
    private int rear = 0;
    private int[] arr;
    
    public queue(int maxSize){
        this.maxSize = maxSize;
        arr = new int[this.maxSize];
    }
    
    public boolean isEmpty(){
        return this.front == this.rear;
    }
    
    public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }
    
    public void addQueue(int value){
        if(isFull()){
            System.out.println("queue is full.");
            return;
        }
        arr[rear] = value;
        rear = (rear + 1) % maxSize;
    }
    
    public int delQueue(){
        if(isEmpty()){
            throw new RuntimeException("queue is empty.");
        }
        int value = arr[front];
        front = (front + 1) % maxSize;
        return value;
    }
    
    public void show(){
        if(isEmpty()){
            System.out.println("queue is empty");
            return;
        }
        for(int i = front; i < front + size(); i++){
            System.out.printf("arr[%d] = %d\n", i % maxSize, arr[i%maxSize]);
        }
    }
    
    public int size(){
        return (rear - front + maxSize) % maxSize;
    }
    
    public int getHead(){
        if(isEmpty()){
            throw new RuntimeException("queue is empty.");
        }
        return arr[front];
    }
	public static void main (String[] args) throws java.lang.Exception
	{
		queue myq = new queue(4);
		myq.addQueue(1);
		myq.addQueue(2);
		myq.addQueue(3);
		myq.addQueue(4);
		
		int value = myq.delQueue();
		System.out.printf("value is %d:\n",value);
		
		myq.addQueue(4);
		System.out.printf("head is %d:\n", myq.getHead());
		myq.show();
	}
}