队列 Queue

一、队列(Queue)

1.1 概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 。
入队列：进行插入操作的一端称为队尾（Tail/Rear） ；
出队列：进行删除操作的一端称为队头（Head/Front）。

1.2 队列的使用

在Java中，Queue是个接口，底层是通过链表实现的。

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

区别： offer方法在容量受限制的情况下，不会抛异常；而add方法会直接抛异常（上图三组方法同理）。不同场景下选择合适方法使用：比如链表结构一般不用考虑容量问题，所以选择offer方法。

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

Queue<Integer> queue = new LinkedList<>();

1.3 队列模拟实现

队列中既然可以存储元素，那底层肯定要有能够保存元素的空间，通过前面线性表的学习了解到常见的空间类型有两种：顺序结构 和 链式结构。同学们思考下：队列的实现使用顺序结构还是链式结构好？

Java当中的队列其实就是双向链表来实现的，但是今天我们上一点难度，用单链表实现：
1.从头入队：入队时间复杂度:O(1)；出队的时间复杂度:O(n)
2.从尾入队：入队时间复杂度:O(n)；出队的时间复杂度:O(1)

呢如何能做到出队和入队的时间复杂度是O(1)呢？
给单链表加上一个tail引用就解决了：（从尾入，从头出）

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

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;
    public ListNode tail;
    public int usedSize;

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

    public int poll(){
        if(head == null){
            return -1;     // 或者抛异常！
        }
        int ret = head.val;
        head = head.next;
        if(head == null) {
            tail = null;
        }
        usedSize--;
        return ret;
    }

    public int peek(){
        if(head == null){
            return -1;    // 或者抛异常！
        }
        return head.val;
    }

    public boolean isEmpty(){
        return usedSize == 0;   // 或者 head == null
    }

    public int getUsedSize(){
        return usedSize;
    }
}

public class Test {
    public static void main(String[] args) {
        MyQueue queue = new MyQueue();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        queue.offer(4);

        System.out.println(queue.poll());
        System.out.println(queue.peek());
        System.out.println(queue.peek());
        System.out.println(queue.isEmpty());
        System.out.println(queue.getUsedSize());
    }
}

1.4 循环队列

实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列通常使用数组实现。


有如下两个问题：
1.rear和front又相遇了，怎么判断这个时候是空的还是满的?

• 计数器

• 浪费一个空间：每次存放元素的时候，都去检查当前的rear下一个是不是front：
  

• 使用标记（flag）

2.rear怎么从7位置走到0位置?

rear = (rear+1) % len
适用于所有情况，比如：
(7+1) % 8 = 0；
(2+1) % 8 = 3；

设计循环队列 OJ链接

代码实现：
在这里我们使用 “浪费一个空间” 的方法，但是由于OJ是不清楚你的思想的，所以在这里我们让构造方法多构造一个空间。

class MyCircularQueue {

    private int[] elem;
    public int front; // 队头
    public int rear; // 队尾

    public MyCircularQueue(int k) {
        elem = new int[k+1];
    }
    
    // 入队列
    public boolean enQueue(int value) {
        if(isFull()){
            return false;
        }
		elem[rear] = value;
        rear = (rear+1) % elem.length;
        return true;
    }
    
    // 出队列
    public boolean deQueue() {
        if(isEmpty()){
            return false;
        }
        front = (front+1) % elem.length;
        return true;
    }
    
    // 获取队头元素
	public int Front() {
        if(isEmpty()){
            return -1;
        }
        return elem[front];
    }
    
    // 获取队尾元素
    public int Rear() {
        if(isEmpty()){
            return -1;
        }
        int index = rear == 0 ? elem.length-1 : rear-1;
        return elem[index];
    }
    
    public boolean isEmpty() {
		if(front == rear){
            return true;
        }
        return false;
    }
    
    public boolean isFull() {
        if((rear+1) % elem.length == front){
            return true;
        } 
        return false;
    }
}

二、双端队列 (Deque)

双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。

Deque是一个接口，使用时必须创建LinkedList的对象。

在实际开发中Deque使用的并不是非常多。

三、面试题

3.1 用队列实现栈

OJ链接

思路：
创建两个队列。
入栈：入到不为空的队列当中；
出栈：就是找到不为空的队列，出size-1个元素到另一个队列当中去。

细节：
1.写pop方法时，下面的循环条件是错误的：

所以我们应该提前记录下来size()。

代码实现：

class MyStack {

    private Queue<Integer> qu1;
    private Queue<Integer> qu2;

    public MyStack() {
        qu1 = new LinkedList<>();
        qu2 = new LinkedList<>();
    }
    
    public void push(int x) {
        if(!qu1.isEmpty()){
            qu1.offer(x);
        }else if(!qu2.isEmpty()){
            qu2.offer(x);
        }else{
            qu1.offer(x);
        }
    }
    
    public int pop() {
        if(empty()){
            return -1;
        }
        if(!qu1.isEmpty()){
            int size = qu1.size();
            for(int i = 0;i < size-1; i++){
                qu2.offer(qu1.poll());
            }
            return qu1.poll();
        }else{
            int size = qu2.size();
            for(int i = 0;i < size-1; i++){
                qu1.offer(qu2.poll());
            }
            return qu2.poll();
        }
    }
    
    // peek
    public int top() {
        if(empty()){
            return -1;
        }
        if(!qu1.isEmpty()){
            int size = qu1.size();
            int ret = -1;
            for(int i = 0;i < size; i++){
                ret = qu1.poll();
                qu2.offer(ret);
            }
            return ret;
        }else{
            int size = qu2.size();
            int ret = -1;
            for(int i = 0;i < size; i++){
                ret = qu2.poll();
                qu1.offer(ret);
            }
            return ret;
        }
    }

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

3.2 用栈实现队列

OJ链接

思路：
创建两个栈：
入队：直接放到第一个栈当中；
出队：出第二个栈当中的数据，如果第2个栈没有数据，那么就把第一个栈当中所有的数据导入第二个栈。

代码实现：

class MyQueue {

    private Stack<Integer> s1;
    private Stack<Integer> s2;

    public MyQueue() {
        s1 = new Stack<>();
        s2 = new Stack<>();
    }
    
    public void push(int x) {
        s1.push(x);
    }
    
    public int pop() {
		if(empty()){
            return -1;
        }
        if(!s2.empty()){
            return s2.pop();
        }else{
            int size = s1.size();
            for(int i = 0;i < size; i++){
                s2.push(s1.pop());
            }
            return s2.pop();
        }
    }
    
    public int peek() {
		if(empty()){
            return -1;
        }
        if(!s2.empty()){
            return s2.peek();
        }else{
            int size = s1.size();
            for(int i = 0;i < size; i++){
                s2.push(s1.pop());
            }
            return s2.peek();
        }
    }
    
    public boolean empty() {
        return s1.empty() && s2.empty();
    }
}