双向队列（Double-ended Queue），也称为双端队列或简称为Deque，是一种具有队列和栈性质的数据结构。它允许在队列的两端进行插入和删除操作，因此可以同时支持先进先出（FIFO）和后进先出（LIFO）的操作。

基本介绍

双向队列的特点是可以在队列的前端和后端进行元素的插入和删除。这意味着你可以在队列的头部和尾部都执行入队出队操作和头部和尾部的访问

双向队列（Double-ended Queue）具有以下特点：

插入和删除操作：双向队列允许在队列的前端和后端进行插入和删除操作。这意味着你可以在队列的头部和尾部同时执行入队和出队操作，使得元素的插入和删除更加灵活和高效。
先进先出（FIFO）和后进先出（LIFO）：由于双向队列同时支持队列和栈的操作，你可以根据需要选择先进先出或后进先出的插入和删除方式。你可以将它用作普通队列，按照先进先出的顺序处理元素，也可以将其用作栈，按照后进先出的顺序处理元素。
随机访问：双向队列通常支持随机访问，也就是可以直接访问队列中的任意位置的元素。这意味着你可以通过索引来访问队列中特定位置的元素，而不仅仅限于头部和尾部的操作。
动态扩容：双向队列通常具有动态扩容的能力。当队列满时，可以自动分配更多的内存空间来容纳更多的元素，从而避免了固定容量的限制。
多种应用场景：双向队列在许多应用场景中非常有用。它可以用于实现队列、栈、滑动窗口问题、任务调度、缓存管理等，提供了一种灵活且高效的数据结构选择。

经典实现

基于双向链表的实现

对于双向队列而言，头部和尾部都可以执行入队和出队操作。换句话说，双向队列需要实现另一个对称方向的操作。为此，可以采用"双向链表"作为双向队列的底层数据结构。

java 复制代码

/* 双向链表节点 */
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 int pop(boolean isFront) {
        if (isEmpty())
            throw new IndexOutOfBoundsException();
        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 int popFirst() {
        return pop(true);
    }

    /* 队尾出队 */
    public int popLast() {
        return pop(false);
    }

    /* 访问队首元素 */
    public int peekFirst() {
        if (isEmpty())
            throw new IndexOutOfBoundsException();
        return front.val;
    }

    /* 访问队尾元素 */
    public int peekLast() {
        if (isEmpty())
            throw new IndexOutOfBoundsException();
        return 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;
    }
}

基于数据的实现

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