「C/C++」C++ STL容器库 之 std::deque 双端队列容器

原创 已于 2024-10-23 12:47:57 修改 · 1.1k 阅读 · 24 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #c++ #开发语言

于 2024-10-23 12:38:16 首次发布

在这里插入图片描述

✨博客主页
何曾参静谧的博客
📌文章专栏
「C/C++」C/C++程序设计
📚全部专栏
「VS」Visual Studio「C/C++」C/C++程序设计「UG/NX」BlockUI集合
「Win」Windows程序设计「DSA」数据结构与算法「UG/NX」NX二次开发
「QT」QT5程序设计「File」数据文件格式「PK」Parasolid函数说明

目录

std::deque 容器详解

std::deque（双端队列）是C++标准模板库（STL）中的一种序列容器，它提供了动态数组的功能，但与std::vector不同的是，std::deque允许在容器的两端高效地插入和删除元素。本文将详细介绍std::deque的使用，包括引用头文件、函数构造、对象初始化、元素访问、迭代器、容器操作、修改器以及元素比较等方面。
在这里插入图片描述
上图截图为黑马C++课程

1. 引用头文件

要使用std::deque，首先需要包含相应的头文件：

#include <deque>
2. 函数构造与对象初始化

std::deque提供了多种构造函数来创建和初始化容器对象。

#include <iostream>
#include <deque>

int main() {
    // 1. 默认构造函数，创建一个空的双端队列
    std::deque<int> dq1;

    // 2. 填充构造函数，创建一个包含5个元素的双端队列，所有元素初始化为0
    std::deque<int> dq2(5, 0);

    // 3. 列表初始化构造函数，创建一个包含指定元素的双端队列
    std::deque<int> dq3 = {1, 2, 3, 4, 5};

    // 输出dq3的内容
    for (int n : dq3) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    return 0;
}
3. 对象初始化与元素访问

在这里插入图片描述

在创建std::deque对象后，可以通过多种方式访问其元素。

#include <iostream>
#include <deque>

int main() {
    std::deque<int> dq = {10, 20, 30, 40, 50};

    // 1. 使用下标操作符访问元素
    std::cout << "Element at index 2: " << dq[2] << std::endl; // 输出30

    // 2. 使用at函数访问元素（带边界检查）
    try {
        std::cout << "Element at index 4: " << dq.at(4) << std::endl; // 输出50
    } catch (const std::out_of_range& e) {
        std::cerr << "Out of range error: " << e.what() << std::endl;
    }

    // 3. 使用front和back函数访问第一个和最后一个元素
    std::cout << "First element: " << dq.front() << std::endl; // 输出10
    std::cout << "Last element: " << dq.back() << std::endl;   // 输出50

    return 0;
}
4. 迭代器

在这里插入图片描述

std::deque支持双向迭代器，允许在容器中向前和向后遍历元素。

#include <iostream>
#include <deque>

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

    // 1. 使用正向迭代器遍历双端队列
    for (std::deque<int>::iterator it = dq.begin(); it != dq.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 2. 使用反向迭代器遍历双端队列
    for (std::deque<int>::reverse_iterator rit = dq.rbegin(); rit != dq.rend(); ++rit) {
        std::cout << *rit << " ";
    }
    std::cout << std::endl;

    return 0;
}
5. 容器操作

在这里插入图片描述

std::deque提供了多种容器操作函数，如size、empty、resize、max_size和swap。

#include <iostream>
#include <deque>

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

    // 1. 获取容器大小
    std::cout << "Size of deque: " << dq.size() << std::endl; // 输出3

    // 2. 检查容器是否为空
    std::cout << "Is deque empty? " << (dq.empty() ? "Yes" : "No") << std::endl; // 输出No

    // 3. 调整容器大小（如果新大小大于当前大小，则新元素初始化为0）
    dq.resize(5);
    std::cout << "Size after resize: " << dq.size() << std::endl; // 输出5

    // 4. 获取容器能容纳的最大元素数量
    std::cout << "Max size of deque: " << dq.max_size() << std::endl;

    // 5. 交换两个容器的内容
    std::deque<int> dq2 = {10, 20, 30};
    dq.swap(dq2);
    std::cout << "dq after swap: ";
    for (int n : dq) {
        std::cout << n << " ";
    }
    std::cout << std::endl; // 输出10 20 30

    return 0;
}
6. 修改器

在这里插入图片描述

std::deque提供了多种修改器函数来插入、删除和替换元素。

#include <iostream>
#include <deque>

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

    // 1. 在末尾插入元素
    dq.push_back(6);
    // 2. 在开头插入元素
    dq.push_front(0);

    // 输出dq的内容
    std::cout << "Deque after push_back and push_front: ";
    for (int n : dq) {
        std::cout << n << " ";
    }
    std::cout << std::endl; // 输出0 1 2 3 4 5 6

    // 3. 从末尾删除元素
    dq.pop_back();
    // 4. 从开头删除元素
    dq.pop_front();

    // 输出dq的内容
    std::cout << "Deque after pop_back and pop_front: ";
    for (int n : dq) {
        std::cout << n << " ";
    }
    std::cout << std::endl; // 输出1 2 3 4 5

    // 5. 在指定位置插入元素
    dq.insert(dq.begin() + 2, 99);

    // 输出dq的内容
    std::cout << "Deque after insert: ";
    for (int n : dq) {
        std::cout << n << " ";
    }
    std::cout << std::endl; // 输出1 2 99 3 4 5

    // 6. 删除指定位置的元素
    dq.erase(dq.begin() + 2);

    // 输出dq的内容
    std::cout << "Deque after erase: ";
    for (int n : dq) {
        std::cout << n << " ";
    }
    std::cout << std::endl; // 输出1 2 3 4 5

    return 0;
}
7. 元素比较

在这里插入图片描述

虽然std::deque本身不直接提供元素比较的成员函数，但可以使用标准库中的算法函数（如std::equal）来比较两个std::deque对象的内容。

#include <iostream>
#include <deque>
#include <algorithm> // for std::equal

int main() {
    std::deque<int> dq1 = {1, 2, 3, 4, 5};
    std::deque<int> dq2 = {1, 2, 3, 4, 5};
    std::deque<int> dq3 = {1, 2, 3, 6, 5};

    // 比较两个双端队列是否相等（按元素顺序和值）
    bool areEqual1 = std::equal(dq1.begin(), dq1.end(), dq2.begin());
    bool areEqual2 = std::equal(dq1.begin(), dq1.end(), dq3.begin());

    std::cout << "dq1 and dq2 are equal? " << (areEqual1 ? "Yes" : "No") << std::endl; // 输出Yes
    std::cout << "dq1 and dq3 are equal? " << (areEqual2 ? "Yes" : "No") << std::endl; // 输出No

    return 0;
}

总结

std::deque（双端队列）是C++标准模板库（STL）中一个非常灵活且功能强大的序列容器。它结合了std::vector的动态数组特性和std::list的双向链表特性，允许在容器的两端高效地插入和删除元素，同时提供了随机访问功能。

应用场景

  1. 动态数组扩展：

    • 当需要一个可以动态调整大小的数组，并且需要在数组的两端频繁插入或删除元素时，std::deque是一个很好的选择。与std::vector相比，std::deque在两端插入和删除元素时的性能更优，因为它不需要像std::vector那样在内存中进行大量的数据搬移。

  2. 队列和栈的实现：

    • std::deque可以很方便地用作队列（FIFO，先进先出）和栈（LIFO，后进先出）的实现。对于队列，可以使用push_back在尾部插入元素，使用pop_front在头部删除元素；对于栈，则可以使用push_front在头部插入元素，使用pop_front在头部删除元素。

  3. 滑动窗口算法：

    • 在处理滑动窗口问题时，std::deque可以高效地存储当前窗口内的元素，并允许在窗口的两端进行快速的插入和删除操作。这对于解决一些数组或字符串处理中的滑动窗口问题特别有用。

  4. 缓存和缓冲区：

    • std::deque可以用作缓存或缓冲区，存储临时数据。由于它允许在两端进行高效的插入和删除操作，因此非常适合用于需要频繁更新数据结构的场景。

  5. 数据流的处理：

    • 在处理数据流时，std::deque可以存储最近接收到的数据，并根据需要丢弃旧数据或添加新数据。这对于实时数据处理和流处理应用特别有用。

  6. 算法和数据结构中的辅助容器：

    • 在实现一些复杂的算法和数据结构时，std::deque可以作为辅助容器来存储中间结果或临时数据。它的高效性和灵活性使其成为许多算法和数据结构实现中的理想选择。

综上所述，std::deque是一个功能强大且灵活的容器，适用于多种应用场景。它的高效性和易用性使其成为C++程序员在处理动态数据结构时的有力工具。

在这里插入图片描述

一篇搞懂C++ STL双端队列std::deque
m0_62599305的博客
08-30 1421
在C++标准模板库（STL）中，std::deque是一种常用的容器，它代表了双端队列（Double-ended Queue）。与相比，std::deque允许高效地在容器的两端插入和删除元素，而只能高效地在尾部进行这些操作。本篇文章将深入探讨std::deque的定义、与std::queue的区别，并详细介绍std::deque的构造函数和操作函数，帮助你全面掌握这一重要的容器。std::deque（双端队列）是一种动态数组，支持在两端快速插入和删除元素。
c++11 标准模板（STL）（std::deque）（一）
qq_40788199的博客
12-29 544
std::deque （ double-ended queue ，双端队列）是有下标顺序容器，它允许在其首尾两段快速插入及删除。另外，在 deque 任一端插入或删除不会非法化指向其余元素的指针或引用。
C++ 标准模板库（STL）——deque的使用
zhu_ing的专栏
11-19 1193
（双端队列）是 C++ 标准模板库（STL）中的一个序列容器，它支持在容器的前端和后端高效地插入和删除元素。end()：返回一个指向容器最后一个元素之后位置的迭代器（这是一个“尾后”迭代器，不指向任何有效元素）。rend()：返回一个指向容器第一个元素之前位置的反向迭代器（这也是一个“尾后”迭代器）。返回指向 std::deque 最后一个元素和第一个元素之前位置的反向迭代器。返回指向 deque 第一个元素和最后一个元素之后位置的迭代器。rbegin()：返回一个指向容器最后一个元素的反向迭代器。
[转]STL之deque容器详解
weixin_30929011的博客
04-14 723
Deque 容器 deque容器是C++标准模版库(STL,Standard Template Library)中的部分内容。deque容器类与vector类似，支持随机访问和快速插入删除，它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是，deque还支持从开始端插入数据：push_front()。 使用deque容器之前必须加上<deque>头文件：#incl...
std::deque
TimerSea的博客
03-30 4205
std::deque应用记录
STD DEQUE
qq_41278986的博客
07-05 1037
指导思想 典型实现用单独分配的固定大小数组的序列。 关于buffer inline size_t __deque_buf_size(size_t __size) { return __size < 512 ? size_t(512 / __size) : size_t(1); } 固定大小(512字节)的buffer能容纳的最大目标类型数量。 buffer即为典型实现用单独分配的固定大小数组。 迭代器 迭代器类型为随机访问迭代器，实现[n]、+n template <class _T
C++ std::deque
肥猫王德福的博客
02-02 5291
重点： deque: double-end queue，双端队列 std::deque 不像 vector 把所有的对象保存在一块连续的内存块，而是采用多个连续的存储块，在一个映射结构中对这些内存块及顺序进行跟踪。 优点快速地随机访问，支持[ ]操作符和at()。首尾两端进行快速的push、pop操作O(1)，支持其他位置插入和删除操作O(n) 。 缺点:内存占用较多。 1. deque、构造函数1.1 deque简介   1. deque、构造函数 1.1 deque简介   std::dequ.
【C++ STL序列容器】deque 双端队列
普罗米修斯的博客
04-06 1310
当操作对象是容器时，它和容器包含的 begin() 和 end() 成员函数的功能完全相同；如果操作对象是普通数组，则 begin() 函数返回的是指向数组第一个元素的指针，同样 end() 返回指向数组中最后一个元素之后一个位置的指针（注意不是最后一个元素）。deque 容器还有一个std::swap(x , y) 非成员函数（其中 x 和 y 是存储相同类型元素的 deque 容器），它和 swap() 成员函数的功能完全相同，仅使用语法上有差异。deque 还擅长在序列头部添加或删除元素。
突破编程_C++_STL教程（ deque 的基础知识）
突破编程
03-04 1227
C++ STL教程：deque 的基础知识
c++11 标准模板（STL）（std::deque）（八）
qq_40788199的博客
01-05 585
从容器擦除指定的元素。 后附给定元素 value 到容器尾。 添加新元素到容器尾。元素通过 std::allocator_traits::construct 构造，它典型地用布置 new 于容器所提供的位置原位构造元素。
std::deque简单使用
MusicMan
01-03 622
deque可以支持前后插入 和前后删除，可以理解成是队列形式 使用代码 // ParamsDemo.cpp : 定义控制台应用程序的入口点。 // C++ 不定参数的方法实现 #include "stdafx.h" using namespace std; int sum(int count,...) { if(count<=0) return 0; va_list arg_...
C++容器之std::deque
weixin_40332490的博客
02-26 1008
和空 std::array 容器不同，空的 std::deque 容器在创建之后可以做添加或删除元素的操作，因此这种简单创建 deque 容器的方式比较常见。创建一个具有 10 个元素(默认为 0)的 deque 容器。创建一个包含 10 个元素(值都为 5)的 deque 容器。注意：采用此方式时必须保证新旧容器存储的元素类型一致。//拷贝普通数组，创建deque容器//适用于所有类型的容器//拷贝arr容器中的{13,14,15}
c++ std::deque
最新发布
weixin_45524582的博客
05-15 336
它的全称是Double-Ended Queue，允许你在队列的两端（头部和尾部）高效地插入和删除元素。结合了数组和链表的优点，提供了快速的随机访问和高效的插入/删除操作。支持随机访问，可以通过索引快速访问元素，时间复杂度为O(1)。• 随机访问：支持通过索引快速访问元素，时间复杂度为O(1)。允许在头部和尾部高效地插入和删除元素，时间复杂度为O(1)。• 高效插入和删除：在头部和尾部的操作时间复杂度为O(1)。的大小可以根据需要动态扩展，不需要预先分配固定大小。的大小是动态的，可以根据需要自动扩展。
std::deque（双端队列）
weixin_67051070的博客
04-02 827
LeetCode239单调队列
05 std::deque
cfz751740465的博客
01-10 301
deque双向队列, 与vector相似, 采用动态数组管理元素, 提供随机访问, 有着与vector几乎一样的接口. 不同的是deque头尾都开放,能在头尾两端快速插入删除。 #include <deque> 1. deque与vector相比 (1) 两端都能快速插入删除元素, 常量时间内完成; vector只能在尾部操作 (2) 访问元素时, 内部结构会多一个间接过程, 元素的访问和迭代操作稍慢 (3) 迭代器需在不同区块间跳转, 所以必须是一个smart pointer.
STL中的deque
稚与的博客
07-07 1018
STL中的deque 文章目录STL中的dequedeque 双端队列程序演示 deque 双端队列 deque是双向队列容器，由一段一段的定量连续空间构成，可以向两端发展，因此在头尾安插元素十分方便、迅速。 在中间部分安插元素则比较费时，因为必须移动其它元素。 头文件 #include<deque> 常用api deque<type>obj 声明deque deque<int> obj; //声明int类型双端队列 deque<int
C++ STL 序列性容器之 std::deque 容器
l357630798的专栏
12-13 1115
deque 是 double-ended deque 的缩写。它是一种动态数组形式，可以向两端发展，因此不论在尾部或头部插入元素，都十分迅速。
c++：双端队列容器（std::deque）
2402_88047672的博客
05-10 1260
std::deque 是 双端队列容器，允许在队列两端进行快速插入和删除。 它的全称是：Double Ended Queue 你可以把它看作是： vector 的增强版，可以在头尾都插入删除，但依然支持随机访问。
C++ STL顺序容器详解：vector、list、deque等用法与原理
deque是一种双端队列，可以在容器的两端高效地插入和删除元素。它在内存中并不是连续存储的，但它提供了类似vector的随机访问能力。 #### 常用函数： - `push_back(T val)`：在deque末尾添加一个新元素。 - `push_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

何曾参静谧

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值