《双向队列》

介绍

双向队列（deque，全名double-ended queue）是一种具有队列和栈性质的数据结构。

对于队列，我们只能在头部删除或在尾部添加元素，

而「双向队列 Deque」更加灵活，在其两端都能执行元素添加或删除操作。

常用操作

方法名	描述	时间复杂度
pushFirst()	将 元素添加至队首	O（1）
pushLast()	将元素添加至队尾	O（1）
pollFirst()	删除队首元素	O（1）
pollLast()	删除队尾元素	O（1）
peekFirst()	访问队首元素	O（1）
peekLast()	访问队尾元素	O（1）
size()	获取队列的长度	O（1）
isEmpty()	判断队列是否为空	O（1）

/*初始化双向队列*/
Deque<Integer> deque = new LinkedList<>();

/*元素入队*/
deque.offerLast(2);//添加至队尾
deque.offerLast(5);
deque.offerLast(4);
deque.offerFirst(3); // 添加至队首
deque.offerFirst(1);

/* 访问元素 */
int peekFirst = deque.peekFirst(); // 队首元素
int peekLast = deque.peekLast(); // 队尾元素

/*元素出队*/
int popFirst = deque.pollFirst(); // 队首元素出队
int popLast = deque.pollLast();// 队尾元素出队

/*获取双向队列的长度 */
int size = deque.size();

/*判断双向队列是否为空*/
boolean isEmpty = deque.isEmpty();

实现

与队列类似，双向队列同样可以使用链表或数组来实现

1.基于双向链表的实现

由于可以方便地删除链表头结点(即出队)，以及在链表尾结点后添加新结点(即入队)，因此我们使用普通单向链表来实现队列，

而双向队列的头部和尾部都可以执行入队与出队操作

换言之，双向队列的操作是“首尾对称”的，也需要实现另一个对称方向的操作

因此，双向队列需要使用「双向链表」来实现

将双向链表的头结点和尾结点分别看作双向队列的队首和队尾，并且实现在两端都能添加与删除结点

/*双向链表节点*/
class ListNode {
    int val; // 节点值
    ListNode next; // 后继节点引用(指针)
    ListNode prev; // 前驱节点引用(指针)
    
    ListNode(int val) {
        this.val = val;
        prev = next = null;
    }
}

/*基于双向链表实现的双向队列*/
class LinkedListDeque {
    private ListNode front, rear; // 头节点front ，尾节点rear
    private int queSize = 0; // 双向队列的长度

    public LinkedListDeque() {
        front = rear = null;
    }

    /*获取双向队列的长度*/
    public int size() {
        return queSize;
    }
    
    /*判断双向队列是否为空*/
    public boolean isEmpty() {
        return size() == 0;
    }

    /*入队操作*/
    private void push(int num, boolean isFront) {
        ListNode node = new ListNode(num);
        // 若链表为空，则令front，rear都指向node
        if (isEmpty()) {
            front = rear = node;
        } else if (isFront) { // 队首入队操作
            // 将node添加至链表头部
            front.prev = node;
            node.next = front;
            front = node; // 更新头节点
        } else { // 队尾入队操作
            // 将node添加至链表尾部
            rear.next = node;
            node.prev = rear;
            rear = node; // 更新尾节点
        }
        queSize++; // 更新队列长度
    }
    
    /*队首入队*/
    public void pushFirst(int num) {
        push(num, true);
    }
    
    /*队尾入队*/
    public void pushLast(int num) {
        push(num, false);
    }

    /*出队操作*/
    private Integer pop(boolean isFront) {
        // 若队列为空，直接返回null
        if (isEmpty()) {
            return null;
        }
        int val;
        if (isFront) { // 队首出队操作
            val = front.val; // 暂存头节点值
            // 删除头节点
            ListNode fNext = front.next;
            if (fNext != null) {
                fNext.prev = null;
                front.next = null;
            }
            front = fNext; // 更新头节点
        } else { // 队尾出队操作
            val = rear.val; // 暂存尾节点值
            // 删除尾节点
            ListNode rPrev = rear.prev;
            if (rPrev != null) {
                rPrev.next = null;
                rear.prev = null;
            }
            rear = rPrev; // 更新尾节点
        }
        queSize--; // 更新队列长度
        return val;
    }
    
    /*队首出队*/
    public Integer popFirst() {
        return pop(true);
    }
    
    /*队尾出队*/
    public Integer popLast() {
        return pop(false);
    }

    /*访问队首元素*/
    public Integer peekFirst() {
        return isEmpty() ? null : front.val;
    }
    
    /*访问队尾元素*/
    public Integer peekLast() {
        return isEmpty() ? null : rear.val;
    }
    
    /*返回数组用于打印*/
    public int[] toArray() {
        ListNode node = front;
        int[] res = new int[size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = node.val;
            node = node.next;
        }
        return res;
    }
}

2.基于环形数组的实现

与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列

在实现队列的基础上，增加实现“队首入队”和“队尾出队”方法即可

/*基于环形数组实现的双向队列*/
class CircularDeque {
    private int capacity; // 队列容量
    private int[] arr; // 存储数据的数组
    private int front; // 头指针，指向队头元素的位置
    private int rear; // 尾指针，指向队尾元素的下一个位置

    public CircularDeque(int k) {
        capacity = k + 1;
        arr = new int[capacity];
        front = 0;
        rear = 0;
    }

    /* 获取双向队列的长度 */
    public int size() {
        return (rear - front + capacity) % capacity;
    }

    /* 判断双向队列是否为空 */
    public boolean isEmpty() {
        return front == rear;
    }

    /* 判断双向队列是否已满 */
    public boolean isFull() {
        return (rear + 1) % capacity == front;
    }

    /* 从队头插入元素 */
    public boolean insertFront(int value) {
        if (isFull()) { // 队列已满
            return false;
        }
        front = (front - 1 + capacity) % capacity; // 计算新的头指针位置
        arr[front] = value;
        return true;
    }

    /* 从队尾插入元素 */
    public boolean insertLast(int value) {
        if (isFull()) { // 队列已满
            return false;
        }
        arr[rear] = value;
        rear = (rear + 1) % capacity; // 计算新的尾指针位置
        return true;
    }

    /* 从队头删除元素 */
    public boolean deleteFront() {
        if (isEmpty()) { // 队列为空
            return false;
        }
        front = (front + 1) % capacity; // 计算新的头指针位置
        return true;
    }

    /* 从队尾删除元素 */
    public boolean deleteLast() {
        if (isEmpty()) { // 队列为空
            return false;
        }
        rear = (rear - 1 + capacity) % capacity; // 计算新的尾指针位置
        return true;
    }

    /* 获取队头元素 */
    public int getFront() {
        if (isEmpty()) { // 队列为空
            return -1;
        }
        return arr[front];
    }

    /* 获取队尾元素 */
    public int getRear() {
        if (isEmpty()) { // 队列为空
            return -1;
        }
        return arr[(rear - 1 + capacity) % capacity];
    }

    /* 入队操作 */
    private void enqueue(int num, boolean isFront) {
        if (isFull()) { // 队列已满，无法入队
            return;
        }
        if (isFront) { // 头部入队
            front = (front - 1 + capacity) % capacity; // 新的头指针位置
            arr[front] = num;
        } else { // 尾部入队
            arr[rear] = num;
            rear = (rear + 1) % capacity; // 新的尾指针位置
        }
    }

    /* 头部入队 */
    public void enqueueFront(int num) {
        enqueue(num, true);
    }

    /* 尾部入队 */
    public void enqueueRear(int num) {
        enqueue(num, false);
    }

    /* 出队操作 */
    private Integer dequeue(boolean isFront) {
        if (isEmpty()) { // 队列为空，无法出队
            return null;
        }
        int res;
        if (isFront) { // 头部出队
            res = arr[front];
            front = (front + 1) % capacity; // 新的头指针位置
        } else { // 尾部出队
            rear = (rear - 1 + capacity) % capacity; // 新的尾指针位置
            res = arr[rear];
        }
        return res;
    }

    /* 头部出队 */
    public Integer dequeueFront() {
        return dequeue(true);
    }

    /* 尾部出队 */
    public Integer dequeueRear() {
        return dequeue(false);
    }

    /* 打印输出双向队列中的元素 */
    public void printDeque() {
        if (isEmpty()) { // 队列为空
            System.out.println("[]");//输出空列表[]
            return;
        }
        StringBuilder sb = new StringBuilder("[");
        for (int i = front; i != rear; i = (i + 1) % capacity) {
            sb.append(arr[i]);
            if ((i + 1) % capacity != rear) {
                sb.append(", ");
            }
        }
        sb.append("]");
        System.out.println(sb.toString());
    }
}
//点提：修改头指针或尾指针时需要取模->保证它们的范围在[0, capacity)之间

环形数组实现双向队列，需要注意头指针和尾指针的计算方法，以及队列判空和判满的条件。