单链表实现队列（Queue）

/**
 * 单链表实现队列
 */
class Node {
    int val;
    Node next;
    public Node(int val){
        this.val = val;
    }
}
public class MyQueue {
    public Node front;//对头
    public Node rear;//队尾
    /**
     * 入队操作,队尾入
     * 参数来源于Node类型，要慢慢留意
     * @param val
     */
    public void offer(int val) {
        Node node = new Node(val);
        if(isEmpty()){//队列为空
            this.front = node;
            this.rear = node;
        }
        else
        {
            this.rear.next = node;
            this.rear = node;//队尾后移
        }
    }
    //是否为空
    public boolean isEmpty(){
        //return this.front == this.rear;有问题，也许都为null，也许指向同一个节点
        return this.front == null;
    }

    /**
     * 出队操作，对头出
     * @return
     */
    public int poll(){
        if(isEmpty()) {//也许队头的值为-1呢，抛异常
            throw new RuntimeException("对列为空，无法出栈！！！");//最好抛自定义异常
        }
        else//不为空，得考虑队列只有一个节点或多个节点
        {
            int temp = this.front.val;//存储val值
            if(front == rear){//对列只有一个节点
                this.front = null;
                this.rear = null;
                return temp;
            }
            else{
                this.front = this.front.next;
                return temp;
            }
        }

    }
    //返回对头元素
    public int peek(){
        if(isEmpty()) {//也许队头的值为-1呢？？？
            throw new RuntimeException("对列为空，无法返回队头元素！");//最好抛自定义异常
        }
            return this.front.val;
    }
}

数组实现循环队列（Queue）

思路：损失一个数组空间来判断队列是否为满

/**
 * MyCircularQueue(k): 构造器，设置队列长度为 k 。
 * Front: 从队首获取元素。如果队列为空，返回 -1 。
 * Rear: 获取队尾元素。如果队列为空，返回 -1 。
 * enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
 * deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
 * isEmpty(): 检查循环队列是否为空。
 * isFull(): 检查循环队列是否已满。
 */
public class MyCircularQueue {
   public int front = 0;
   public int rear = 0;
   int[] elem;
    public MyCircularQueue(int k) {
        this.elem = new int[k];
    }

    public boolean enQueue(int value) {
        if(isFull()){
            return false;
        }
        this.elem[this.rear] = value;
        //this.rear = this.rear + 1;//得进行循环
        this.rear = (this.rear + 1) % elem.length;
        return true;
    }

    public boolean deQueue() {
        if(isEmpty()){
            return false;
        }
        //this.front = this.front + 1;
        this.front = (this.front + 1) % this.elem.length;
        return true;
    }

    public int Front() {
        if(isEmpty()){
            return -1;
        }
        return this.elem[this.front];
    }

    public int Rear() {
        if(isEmpty()){
            return -1;
        }
        //return this.elem[this.rear];错误写法
        if(this.rear == 0){
            return elem[this.elem.length  - 1];
        }
        return elem[this.rear - 1];
    }
    /**
    *在循环队列中，rear指向的是下一个可以存放元素的位置，
    *如果front==rear，那不就代表为空了,但是在链表中可不一样
    */
    public boolean isEmpty() {
        if(this.front == this.rear){
            return true;
        }
        return false;
    }

    public boolean isFull() {
        //if(this.rear + 1 == this.front){//错误写法
        if((this.rear + 1) % this.elem.length == this.front){
            return true;
        }
        return false;
    }
}