环形队列与普通队列

public class MyQueue {
    public static void main(String[] args) {
        ArrayQueue arrayQueue = new ArrayQueue(4);
        arrayQueue.addQueue(8);
        arrayQueue.addQueue(2);
        System.out.println(arrayQueue.getHead());
        System.out.println(arrayQueue.getTail());
        System.out.println(arrayQueue.isEmpty());
        System.out.println(arrayQueue.getQueue());
        System.out.println(arrayQueue.getHead());

        System.out.println("===========================");
        CircleQueue circleQueue = new CircleQueue(4);
        circleQueue.addQueue(87);
        circleQueue.addQueue(27);
        circleQueue.addQueue(36);
        circleQueue.addQueue(2);
        circleQueue.addQueue(14);
        System.out.println("size:" + circleQueue.size());
        System.out.println("head:" + circleQueue.getHead());
        System.out.println("tail:" + circleQueue.getTail());
        circleQueue.traverse();
        System.out.println("poll queue:" + circleQueue.getQueue());
        System.out.println("poll queue:" + circleQueue.getQueue());
        System.out.println("poll queue:" + circleQueue.getQueue());
    }
}

/**
 * 普通队列
 * front:指向队列头的前一个位置，默认值-1
 * rear:指向队列尾的位置，默认值-1
 * 判断对列为空：front == rear
 * 判断对列已满：rear = maxSize-1
 */
class ArrayQueue {
    private int maxSize;
    private int front;
    private int rear;
    private int[] arr;

    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        this.front = -1;
        this.rear = -1;
        arr = new int[maxSize];
    }

    public boolean isFull() {
        return rear == maxSize - 1;
    }

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

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

    public int getQueue() {
        if (isEmpty()) {
            System.out.println("queue is empty");
            throw new RuntimeException("queue is empty");
        }
        front++;
        return arr[front];
    }

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

    public int getTail() {
        if (isEmpty()) {
            System.out.println("queue is empty");
            throw new RuntimeException("queue is empty");
        }
        return arr[rear];
    }
}

/**
 * 环形对列
 * front:指向队列第一个元素，arr[front]就是第一个元素，front默认为0
 * rear:指向队列最后一个元素的下一个位置，对列末尾空出一个位置，队列的最大size为maxSize-1,rear的默认值为0
 * 判断对列为空：front==rear
 * 判断对列已满：(rear+1)%maxSize == front
 * 对列size:(rear-front+maxSize)%maxSize
 */
class CircleQueue {

    private int maxSise;
    private int front;
    private int rear;
    private int[] arr;

    public CircleQueue(int maxSise) {
        this.maxSise = maxSise;
        arr = new int[maxSise];
    }

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

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

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

    public int getQueue() {
        if (isEmpty()) {
            System.out.println("queue is empty");
            throw new RuntimeException("queue is empty");
        }
        int value = arr[front];
        front = (front + 1) % maxSise;
        return value;
    }

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

    public int getTail() {
        if (isEmpty()) {
            System.out.println("queue is empty");
            throw new RuntimeException("queue is empty");
        }
        return arr[rear - 1];
    }

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

    public void traverse() {
        if (isEmpty()) {
            System.out.println("queue is empty");
            return;
        }
        for (int i = 0; i < front + size(); i++) {
            System.out.println(arr[i]);
        }
    }
}