public class TestDemo5 {
    public static void main(String[] args) {
        //此时是一个普通队列
        Queue<Integer> queue = new LinkedList<>();
        //此时调用add方法，默认是尾部入队.
        queue.add(1);
        //输出普通队列的长度，为1
        System.out.println(queue.size());
    }
}

public class TestDemo5 {
    public static void main(String[] args) {
        //此时是一个普通队列
        Queue<Integer> queue = new LinkedList<>();
        //此时调用add方法，默认是尾部入队.
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        queue.offer(4);
        //此处的输出值为1，代表所删除的队头元素
        System.out.println(queue.poll());
        //此处的输出值为【2，3，4】
        System.out.println(queue);
    }
}

public class TestDemo5 {
    public static void main(String[] args) {
        //此时是一个普通队列
        Queue<Integer> queue = new LinkedList<>();
        //此时调用add方法，默认是尾部入队.
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        queue.offer(4);
        //此处的输出值为1
        System.out.println(queue.peek());
        //此处的输出值为【1,2，3，4】
        System.out.println(queue);
    }
}

public class TestDemo5 {
    public static void main(String[] args) {
        Deque<Integer> deque = new LinkedList<>();
        //从双端队列的队头插入元素
        deque.addFirst(1);
        //从双端队列的队尾插入元素
        deque.addLast(2);
        //输出结果为:[1, 2]
        System.out.println(deque);
    }
}

class Node {
    public int val;
    public Node next;
    public Node(int val) {
        this.val = val;
    }
}
public class MyQueue {
    //定义队列头
    public Node first;
    //定义队列尾
    public Node last;
    //判断列表是否为空
    public boolean isEmpty() {
        if (this.first == null && this.last == null) {
            return true;
        }
        return false;
    }
    //实现队列中的offer方法，在其源码中默认是尾插法
    public boolean offer(int val) {
        Node node = new Node(val);
        //假如此时队列中还没有元素
        if (this.first == null) {
            this.first = node;
            this.last = node;
        } else {
            //假设队列中已经插入了元素
            this.last.next = node;
            this.last = node;
        }
        return true;
    }
    /**
     * 得到队头元素且删除
     *
     * @return
     * @throws RuntimeException
     */
    public int poll() throws RuntimeException {
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        int num = this.first.val;
        this.first = this.first.next;
        return num;
    }
    /**
     * 得到队列的头元素但是不删除
     *
     * @return
     */
    public int peek() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        return this.first.val;
    }
    public static void main(String[] args) {
    }
}

public class MyCircularQueue {
    private int front;
    //rear表示当前可以插入元素的数组的下标
    private int rear;
    private int[] elem;
    public MyCircularQueue(int k) {
        this.elem = new int[k];
    }
    /**
     * 向循环队列插入一个元素。如果成功插入则返回真。
     *
     * @param value
     * @return
     */
    public boolean enQueue(int value) {
        //此时代表队列已满，无法再进行插入
        if (isFull()) {
            return false;
        }
        //放到数组的rear下标
        this.elem[this.rear] = value;
        //rear指针往后走,取余是为了循环起来
        this.rear = (this.rear + 1) % this.elem.length;
        return true;
    }
    public boolean deQueue() {
        if (isEmpty()) {
            return false;
        }
        //只需要挪动front这个下标就好了，取余是为了循环起来
        this.front = (this.front + 1) % this.elem.length;
        return true;
    }
    /**
     * 得到队头元素
     *
     * @return
     */
    public int Front() {
        if (isEmpty()) {
            return -1;
        }
        return this.elem[this.front];
    }
    /**
     * 得到队尾元素
     * 注意特殊情况
     *
     * @return
     */
    public int Rear() {
        if (isEmpty()) {
            return -1;
        }
        int index = -1;
        if (this.rear == 0) {
            index = this.elem.length - 1;
        } else {
            index = this.rear - 1;
        }
        return this.elem[index];
    }
    /**
     * 队列是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return this.rear == this.front;
    }
    /**
     * 队列是否为满
     *
     * @return
     */
    public boolean isFull() {
        return (this.rear + 1) % this.elem.length == this.front;
    }
}