【Java数据结构 -- 队列:队列有关面试oj算法题】

1.队列

1.1 什么是队列

只允许在一端进行插入数据操作，在另一端进行删除数据操作得特殊线性表，队列是先进先出，入队：进行插入操作得一端称为队尾（rear），出队：进行删除操作的一端称为队头(front)。队列Queue是个接口，底层通过链表实现的。

• boolean offer(E e) – 入队列
• E poll() – 出队列
• peek() – 获取队头元素
• int size() – 获取队列中有效元素个数
• boolean isEmpty() – 检测队列是否为空

注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。

1.2 创建队列

public class MyQueue {
    static class ListNode {
        public int val;
        public ListNode prev;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;  // 队头
    public ListNode last;  // 队尾
}

1.3 队列是否为空和获取队头元素 empty()+peek()

    public boolean empty() {
        return head == null;
    }

    public int peek() {
        if (head == null) {
            return -1;
        }
        return head.val;
    }

1.4 入队offer()

入队相当于链表的尾插法，入队元素node，然后队列为空，直接把头尾节点指向node，不为空：从队尾入队操作，last的后节点指向node，node的前节点指向last，last再指向node。

    public void offer(int val) {
        ListNode node = new ListNode(val);
        if (head == null) {
            head = last = node;
        }else {
            last.next = node;
            node.prev = last;
            last = node;
        }
    }

1.5 出队（头删）poll()

给个临时变量val，当只有一个节点时：val指向head.val，出队完head指向null，返回val。不止一个节点：val指向head.val，head指向head的后节点，head的前驱节点指向null，返回val。

    public int poll() {
        if(head == null) {
            return -1;
        }
        //只有一个节点
        int val = -1;
        if (head.next == null) {
            val = head.val;
            head = null;
            return val;
        }
        val = head.val;
        head = head.next;
        head.prev = null;
        return val;
    }

2. 循环队列

假如队列的大小为8，当7走到下一个下标0的时候，下标+1实现不了，所有在循环队列当中，实现数组下标循环：队头：front = (front + 1) % elem.length，队尾：rear = (rear + 1) % elem.length，区分队列空和满：当队头front和队尾rear相遇时为空。当队尾rear的下个为队头front为满。

2.1 创建循环队列

class MyCircularQueue {
    // 循环队列
    public int[] elem;
    public int front;
    public int rear;
    public MyCircularQueue(int k) {
        elem = new int[k+1];
    }
}

2.2 判断是否为空isEmpty()和满isFull()

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

    public boolean isFull() {
        return (rear+1) % elem.length == front;
    }

2.3 入队enQueue()

    public boolean enQueue(int value) {
        if (isFull()) {
            return false;
        }else {
            elem[rear] = value;
            rear = (rear + 1) % elem.length;
            return true;
        }
    }

2.4 出队 deQueue()

    public boolean deQueue() {
        if(isEmpty()) {
            return false;
        }else {
            // 得到数组下标最后再完后的下标  如果最大是8，后面跳转到0
            front = (front + 1) % elem.length;
            return true;
        }
    }

2.5 得到队头元素不删除 Front()

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

2.6 得到队尾元素不删除 Rear()

    public int Rear() {
        if (isEmpty()) {
            return -1;
        }
        int index = (rear == 0) ? elem.length-1 : rear-1;
        return elem[index];
    }

3.用队列模拟栈

在这里用到两个先进先出的队列来实现栈。
思路：

• 1.当两个队列都是空的时候，放到第一个队列
• 2.再次入栈的时候，放到不为空的队列
• 3.出栈的时候，出不为空的队列 出size-1个元素，剩下的元素就是要出栈的元素

3.1 实例化两个队列

class MyStack{
	private Queue<Integer> qu1;
    private Queue<Integer> qu2;

    public MyStack() {
        qu1 = new LinkedList<>();
        qu2 = new LinkedList<>();
    }
}

3.2 判断栈是否为空

判断栈是否为空我们直接返回两个队列是否为空。

    public boolean empty() {
        return qu1.isEmpty() && qu2.isEmpty();
    }

3.1 入栈push()

当两个队列都是空的时候，放到第一个队列，再次入栈的时候，放到不为空的队列

    public void push(int x) {
        if (empty()) {
            qu1.offer(x);
            return;
        }
        if (!qu1.isEmpty()) {
            qu1.offer(x);
        }else {
            qu2.offer(x);
        }
    }

3.2 出栈pop()

找到不为空的队列 出size-1个元素 剩下的元素就是出栈的元素，每弹出一个size都在变小一次，

    public int pop() {
        if (empty()) {
            return -1;
        }
        // 找到不为空的队列 出size-1个元素 剩下的元素就是出栈的元素
        if (!qu1.isEmpty()) {
            int size = qu1.size();
            for (int i = 0; i < size-1; i++) {
                qu2.offer(qu1.poll());
            }
            return qu1.poll();
        }else {
            // 没弹出一个size都在变小一次
            int size = qu2.size();
            for (int i = 0; i < size-1; i++) {
                qu1.offer(qu2.poll());
            }
            return qu2.poll();
        }
    }

3.3 获取栈顶元素top()

和出栈一样，给一个临时变量tmp，用tmp接收队列的最后一个元素。

    public int top() {

        if (empty()) {
            return -1;
        }
        if (!qu1.isEmpty()) {
            int size = qu1.size();
            int tmp = -1;
            for (int i = 0; i < size; i++) {
                tmp = qu1.poll();
                qu2.offer(tmp);
            }
            return tmp;
        }else {
            // 没弹出一个size都在变小一次
            int size = qu2.size();
            int tmp = -1;
            for (int i = 0; i < size; i++) {
                tmp = qu2.poll();
                qu1.offer(tmp);
            }
            return tmp;
        }
    }

4.用栈模拟队列

用栈模拟实现队列也需要用到两个栈，思路：

• 1.入队：把数据放到第一个栈中
• 2.出队：把第一个栈的全部元素放进第二栈当中，出st2这个栈当中的栈顶元素即可，如果st2为空，把st1里面所有的元素全部放到st2
• 3.当两个栈为空 说明模拟的栈队列为空

4.1 实例化两个栈

class MyQueue {
        private Stack<Integer> st1;
        private Stack<Integer> st2;
        public MyQueue() {
            st1 = new Stack<>();
            st2 = new Stack<>();
        }
}

4.2 入队push()

入栈直接全部放进第一个栈中

        public void push(int x) {
            st1.push(x);
        }

4.3 出队pop()

把第一个栈的全部元素放进第二栈当中，出st2这个栈当中的栈顶元素即可，如果st2为空，把st1里面所有的元素全部放到st2

        public int pop() {
            if(empty()) {
                return -1;
            }
            if(st2.empty()) {
                while(!st1.empty()) {
                    st2.push(st1.pop());
                }
            }
            return st2.pop();
        }

4.4 获取队顶元素peek()+队列是否为空empty()

和出队一样，peek第二个栈的栈顶元素即可

        public int peek() {
            if(empty()) {
                return -1;
            }
            if(st2.empty()) {
                while(!st1.empty()) {
                    st2.push(st1.pop());
                }
            }
            return st2.peek();
        }

        public boolean empty() {
            return st1.empty() && st2.empty();
        }