// 一次性陣列佇列
public class Demo3 {
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(5);
        queue.addNum(1);
        queue.addNum(2);
        queue.addNum(3);
        queue.addNum(4);
        queue.addNum(5);
        System.out.println(queue.getNum());
        queue.showQueue();
    }
}

class ArrayQueue {
    //佇列的大小
    int maxSize;
    //用陣列來實現佇列
    int[] arr;
    //指向佇列首元素的前一個位置
    int front;
    //指向佇列的尾元素
    int rear;
    // 構造初始值，佇列長度
    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[this.maxSize];
        //front指向佇列首元素的前一個位置，初始下標為-1
        front = -1;
        rear = -1;
    }

    // 當出隊的下標等於陣列的長度減一時，佇列滿
    public boolean isFull() {
        return rear == maxSize - 1;
    }

    // 佇列為空：出隊與入隊下標一致
    public boolean isEmpty() {
        return front == rear;
    }

    // 新增時判斷對列是否已滿，否，則陣列下標後移賦值
    public void addNum(int num) {
        if(isFull()) {
            System.out.println("佇列已滿，無法在進行入隊操作");
            return;
        }
        //隊尾標記後移，指向要放入的元素的位置，
        rear++;
        arr[rear] = num;
    }
    // 出隊判空，當前預設下標為-1.沒有動過，下標遞增，出隊取值
    public int getNum() {
        if(isEmpty()) {
            throw new RuntimeException("佇列為空，無法出隊");
        }
        //隊首標記後移，指向隊首元素
        System.out.print("出隊元素是：");
        front++;
        return arr[front];
    }

    // 簡單遍歷
    public void showQueue() {
        if(isEmpty()) {
            throw new RuntimeException("佇列為空，無法遍歷");
        }
        System.out.println("遍歷佇列");
        // 遍歷入隊元素，
        for(int start = front+1; start<=rear; start++) {
            System.out.println(arr[start]);
        }
    }
}


// 迴圈佇列，陣列重新利用
public class Demo4 {
    public static void main(String[] args) {
        ArrayAroundQueue aroundQueue = new ArrayAroundQueue(5);
        aroundQueue.addNum(1);
        aroundQueue.addNum(2);
        aroundQueue.addNum(3);
        aroundQueue.addNum(4);
        aroundQueue.showQueue();
        System.out.println(aroundQueue.getNum());
        System.out.println(aroundQueue.getNum());
        aroundQueue.addNum(5);
        aroundQueue.addNum(6);
        aroundQueue.showQueue();
        aroundQueue.getHead();

    }
}

class ArrayAroundQueue {
    //佇列的大小
    int maxSize;
    //用陣列來實現佇列
    int[] arr;
    //指向佇列首元素的前一個位置
    int front;
    //指向佇列的尾元素
    int rear;

    // 初始化陣列佇列
    public ArrayAroundQueue(int maxSize) {
        this.maxSize = maxSize;
        arr = new int[this.maxSize];
        //front ，rear，初始下標值
        front = 0;
        rear = 0;
    }


    def boolean isFull() {
        // 當入隊達到最大下標，出隊為0，說明第一次佇列已滿，重新新增元素
        return (rear+1)%maxSize == front;
    }


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


    public void addNum(int num) {
        if(isFull()) {
            System.out.println("佇列已滿，無法在進行入隊操作");
            return;
        }
        //先放入元素，在後移隊尾標記
        arr[rear] = num;
        // 入隊指標移動：當入隊達到下標最大值時，rear為0，此時，又一輪佇列開始
        rear = (rear+1)%maxSize;
    }

    public int getNum() {
        if(isEmpty()) {
            throw new RuntimeException("佇列為空，無法出隊");
        }
        //隊首標記後移，指向隊首元素
        System.out.print("出隊元素是：");
        // front元素，初始值0，返回元素，同時出隊指標移動
        int num = arr[front];
        // 一輪新的下標開始，下標輪迴
        front = (front+1)%maxSize;
        return num;
    }

    public void showQueue() {
        if(isEmpty()) {
            throw new RuntimeException("佇列為空，無法遍歷");
        }
        System.out.println("遍歷佇列");
        //當front + 1 == rear時停止遍歷，原因是：？
        int start = front;
        while(start != rear) {
            System.out.println(arr[start]);
            //移動到下一個元素，當陣列為10時，下標為9時佇列滿，下一次佇列的下標為0，，當未滿時，按餘數走
            start = (start+1)%maxSize;
        }
    }

    public void getHead() {
        if(isEmpty()) {
            throw new RuntimeException("佇列為空");
        }

        System.out.println("隊首元素為："+arr[front]);
    }
}