std::deque（双端队列）

std::deque（双端队列）是 C++ 标准模板库（STL）中的一个序列容器，它提供了在队列的两端进行插入和删除操作的高效实现。std::deque 可以被视为一个固定大小的数组，但它可以动态增长和缩减，且不需要在每次插入或删除时重新分配整个数组的内存。

std::deque 的主要特点包括：

1. 两端快速访问：可以在 std::deque 的前端和后端快速添加或移除元素。
2. 动态大小：std::deque 的大小可以根据需要动态增长和缩减。
3. 内存效率：std::deque 通常使用多个固定大小的块来存储元素，这有助于减少内存碎片并提高内存访问效率。
4. 无容量限制：与 std::vector 不同，std::deque 没有容量限制，它可以根据需要增长到任何大小（受限于可用内存）。

下面是一些使用 std::deque 的基本示例：

创建和初始化 std::deque

#include <deque>
#include <iostream>

int main() {
    // 创建一个空的 deque
    std::deque<int> deq1;

    // 使用花括号初始化 deque
    std::deque<int> deq2 = {1, 2, 3, 4, 5};

    // 使用另一个 deque 的拷贝初始化
    std::deque<int> deq3(deq2);

    return 0;
}

插入和删除元素

#include <deque>
#include <iostream>

int main() {
    std::deque<int> deq = {1, 2, 3, 4, 5};

    // 在 deque 的前端插入元素
    deq.push_front(0);   // {0，1，2，3，4，5}

    // 在 deque 的后端插入元素
    deq.push_back(6);   // {0，1，2，3，4，5，6}

    // 从 deque 的前端移除元素
    deq.pop_front();   // {1，2，3，4，5，6}

    // 从 deque 的后端移除元素
    deq.pop_back();   // {1，2，3，4，5}

    // 打印 deque 的内容
    for (int num : deq) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

访问元素

std::deque 提供了 front() 和 back() 方法来访问第一个和最后一个元素，但没有直接访问中间元素的方法。要访问中间元素，需要一个指向中间的迭代器，通常通过 begin()、end() 或 find() 等方法获得。

#include <deque>
#include <iostream>

int main() {
    std::deque<int> deq = {1, 2, 3, 4, 5};

    // 访问第一个元素
    std::cout << "Front element: " << deq.front() << std::endl;

    // 访问最后一个元素
    std::cout << "Back element: " << deq.back() << std::endl;

    // 使用迭代器访问中间元素
    auto it = deq.begin() + 2; // 获取指向第三个元素的迭代器
    if (it != deq.end()) {
        std::cout << "Middle element: " << *it << std::endl;
    }

    return 0;
}

遍历 std::deque

可以使用迭代器或范围 for 循环来遍历 std::deque 中的所有元素。

容量和大小

std::deque 提供了 empty()、size() 和 max_size() 方法来查询容器的状态。

#include <deque>
#include <iostream>

int main() {
    std::deque<int> deq;

    // 检查 deque 是否为空
    if (deq.empty()) {
        std::cout << "Deque is empty." << std::endl;
    }

    // 获取 deque 的大小
    std::cout << "Deque size: " << deq.size() << std::endl;

    // 获取 deque 可以容纳的最大元素数量
    std::cout << "Deque max size: " << deq.max_size() << std::endl;

    return 0;
}

std::deque 是一个非常有用的容器，特别是需要在序列的两端频繁地插入和删除元素时。然而，由于它的内部实现使用了几个固定大小的块，所以当插入或删除操作跨越块的边界时，可能会发生额外的内存分配和元素复制，这可能会导致性能开销。因此，在决定使用 std::deque 时，需要根据具体的应用场景来权衡其优缺点。

---

使用 std::deque 实现单调队列是一种常见的做法，因为它支持两端的快速插入和删除操作。单调队列通常用于维护一个区间内的最小值或最大值，例如在处理滑动窗口问题时。下面是使用 std::deque 实现一个单调递增队列的示例，它可以用于计算滑动窗口的最大值：

#include <iostream>
#include <deque>

class MonotonicQueue {
private:
    std::deque<int> dq; // 使用双端队列实现单调队列

public:
    // 向队列尾部添加元素
    void push(int value) {
        // 移除所有比新值小的尾部元素（保持队列单调性）
        while (!dq.empty() && dq.back() < value) {
            dq.pop_back();
        }
        // 将新值添加到队列尾部
        dq.push_back(value);
    }

    // 移除队列头部的元素
    void pop_front() {
        // 只移除队列头部的元素
        if (!dq.empty()) {
            dq.pop_front();
        }
    }

    // 获取队列头部的元素
    int front() {
        if (dq.empty()) {
            throw std::out_of_range("Queue is empty.");
        }
        return dq.front();
    }

    // 获取队列尾部的元素
    int back() {
        if (dq.empty()) {
            throw std::out_of_range("Queue is empty.");
        }
        return dq.back();
    }

    // 检查队列是否为空
    bool empty() {
        return dq.empty();
    }

    // 获取队列的大小
    size_t size() {
        return dq.size();
    }
};

int main() {
    MonotonicQueue mq;
    mq.push(5);
    mq.push(3);
    mq.push(7);
    mq.push(4);
    mq.push(6);

    while (!mq.empty()) {
        std::cout << mq.front() << " ";
        mq.pop_front();
    }
    std::cout << std::endl;

    return 0;
}

LC239

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> res;
        deque<int> q;
        for (int i = 0; i < nums.size(); i++) {
            // 严格维持单调递减
            while (!q.empty() && nums[i] > nums[q.back()]) q.pop_back();
            q.push_back(i);
            if (i-q.front() >= k) q.pop_front();
            if (i >= k-1) res.emplace_back(nums[q.front()]);
        } return res;
    }
};