C++容器之双端队列(std::deque)

已于 2024-05-30 15:43:08 修改
阅读量749 收藏 23
点赞数 16
分类专栏： C++标准库使用 文章标签： c++ deque 双端队列
于 2024-05-28 13:55:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flysnow010/article/details/139265045
版权

目录

1 概述

  deque（通常发音像“deck”）是双端队列的一个不规则缩写。双端队列是具有动态大小的序列容器，可以在两端（前端或后端）进行扩展或收缩。
  特定的库可以以不同的方式实现deques，通常作为某种形式的动态数组。但在任何情况下，它们都允许通过随机访问迭代器直接访问单个元素，并根据需要通过扩展和收缩容器来自动处理存储。
  因此，它们提供了类似于矢量的功能，但也在序列的开始处，而不仅仅是在序列的结束处，有效地插入和删除元素。但是，与向量不同的是，deque不能保证将其所有元素存储在连续的存储位置：通过将指针偏移到另一个元素来访问deque中的元素会导致未定义的行为。
  vectors和deque都提供了非常相似的接口，可以用于类似的目的，但在内部都以完全不同的方式工作：虽然vectors使用一个偶尔需要重新分配才能增长的数组，但deque的元素可以分散在不同的存储块中，容器在内部保留必要的信息，以便在恒定时间内直接访问其任何元素，并具有统一的顺序接口（通过迭代器）。因此，deques的内部比向量复杂一点，但这使它们在某些情况下能够更有效地生长，尤其是在非常长的序列中，重新定位变得更加昂贵。
  对于涉及在除开头或结尾以外的位置频繁插入或删除元素的操作，与列表和前向列表相比，deques的性能更差，迭代器和引用的一致性也更低。

其类图如下：
类图

2 使用实例

void DequeSuite::push_back()
{
    int array[] = { 1, 2, 3, 4, 5 };
    std::deque<int> a;

    for(size_t i = 0; i < ARRAY_SIZE(array); i++)
        a.push_back(array[i]);

    for(size_t i = 0; i < a.size(); i++)
        TEST_ASSERT_EQUALS(array[i],  a[i])
}

void DequeSuite::push_front()
{
    int array[] = { 1, 2, 3, 4, 5 };
    std::deque<int> a;
    std::deque<int> b;

    for(size_t i = 0; i < ARRAY_SIZE(array); i++)
        a.push_front(array[i]);

    int index = 0;
    for(auto it = a.crbegin(); it != a.crend(); ++it)
        TEST_ASSERT_EQUALS(array[index++],  *it)
}

3 接口使用

3.1 construct

std::deque<int> getDeque(int size, int value)
{
    return std::deque<int>(size, value);
}
void DequeSuite::construct()
{
    std::deque<int> a;
    std::deque<int> b(4); // 0 0 0 0
    std::deque<int> c(4, 5);// 5 5 5 5
    std::deque<int> d({1, 2, 3, 4, 5});
    std::deque<int> e(d.begin(), d.end());
    std::deque<int> f(d);
    std::deque<int> g(getDeque(6, 8));

    TEST_ASSERT_EQUALS(0, a.size())
    TEST_ASSERT_EQUALS(4, b.size())
    TEST_ASSERT_EQUALS(4, c.size())
    TEST_ASSERT_EQUALS(5, d.size())
    TEST_ASSERT_EQUALS(5, e.size())
    TEST_ASSERT_EQUALS(5, f.size())
    TEST_ASSERT_EQUALS(6, g.size())
}

3.2 assigns

void DequeSuite::assigns()
{
    std::deque<int> a;
    std::deque<int> b;
    std::deque<int> c;
    a = { 1, 2, 3, 4, 5 };
    b = a;
    c = getDeque(5, 10);

    TEST_ASSERT_EQUALS(5, a.size())
    TEST_ASSERT_EQUALS(5, b.size())
    TEST_ASSERT_EQUALS(5, c.size())
}

3.3 iterators

#define ARRAY_SIZE(array) sizeof(array) / sizeof(array[0])
void DequeSuite::iterators()
{
    int  array[] = { 1, 2, 3, 4, 5 };
    int  rarray[] = { 5, 4, 3, 2, 1 };
    std::deque<int> a(array, array + ARRAY_SIZE(array));
    int index = 0;
    for(auto it = a.begin(); it != a.end(); ++it)
    {
        TEST_ASSERT_EQUALS(array[index++], *it)
    }
    
    index = 0;
    for(auto it = a.cbegin(); it != a.cend(); ++it)
    {
        TEST_ASSERT_EQUALS(array[index++], *it)
    }

    index = 0;
    for(auto it = a.rbegin(); it != a.rend(); ++it)
    {
        TEST_ASSERT_EQUALS(rarray[index], *it)
        rarray[index] = rarray[index] * 2;
        *it = rarray[index++];
    }
    
    index = 0;
    for(auto it = a.crbegin(); it != a.crend(); ++it)
    {
        TEST_ASSERT_EQUALS(rarray[index++], *it)
    }
}

3.4 capacity

void DequeSuite::capacity()
{
    std::deque<int> a;
    std::deque<int> b({1, 2, 3, 4, 5});
    TEST_ASSERT_EQUALS(0, a.size());
    TEST_ASSERT_EQUALS(5, b.size());
    TEST_ASSERT_EQUALS(true, a.empty());
    TEST_ASSERT_EQUALS(false, b.empty());

    TEST_ASSERT_EQUALS(a.max_size(), b.max_size());
}

3.5 rezize

void DequeSuite::rezize()
{
    std::deque<int> a;
    a.resize(5, 10);  //10 10 10 10 10
    for(auto it = a.begin(); it != a.end(); ++it)
        TEST_ASSERT_EQUALS(10, *it);
    a.resize(8);      //10 10 10 10 10 0 0 0
    for(auto it = a.begin(); it != a.begin() + 5; ++it)
        TEST_ASSERT_EQUALS(10, *it);
    for(auto it = a.begin() + 5; it != a.end(); ++it)
        TEST_ASSERT_EQUALS(0, *it);
    a.resize(10, 20); //10 10 10 10 10 0 0 0 20 20
    for(auto it = a.begin() + 10; it != a.end(); ++it)
        TEST_ASSERT_EQUALS(20, *it);
}

3.6 shrink_to_fit

void DequeSuite::shrink_to_fit()
{
    std::deque<int> a (100);
    TEST_ASSERT_EQUALS(100, a.size())
    a.resize(10);
    TEST_ASSERT_EQUALS(10, a.size())
    a.shrink_to_fit();
}

说明:

  • 该函数不修改size大小

3.7 access

void DequeSuite::access()
{
    int  array[] = { 1, 2, 3, 4, 5 };
    std::deque<int> a(array, array + ARRAY_SIZE(array));
    

    TEST_ASSERT_EQUALS(1, a.front())//size of a must more than 0
    TEST_ASSERT_EQUALS(5, a.back()) //size of a must more than 0

    for(size_t i = 0; i < a.size(); i++)
    {
        TEST_ASSERT_EQUALS(array[i], a[i])
         array[i] = a[i] * 2;
        a[i] = array[i];
    }
    TEST_ASSERT_EQUALS(2, a.front())
    TEST_ASSERT_EQUALS(10, a.back())

    for(size_t i = 0; i < a.size(); i++)
    {
        TEST_ASSERT_EQUALS(array[i], a.at(i))
        array[i] = a.at(i) / 2;
        a.at(i) = array[i];
    }
    TEST_ASSERT_EQUALS(1, a.front())
    TEST_ASSERT_EQUALS(5, a.back())

    bool hasExcpetion = false;
    try {
        int v = a.at(6);
    }
    catch(...)
    {
        hasExcpetion = true;
    }
    TEST_ASSERT_EQUALS(true, hasExcpetion)
}

3.8 assign

void DequeSuite::assign()
{
    std::deque<int> a;
    std::deque<int> b;
    std::deque<int> c;
    a.assign({ 1, 2, 3, 4, 5 });
    b.assign(a.begin(), a.end());
    c.assign(4, 5);

    TEST_ASSERT_EQUALS(5, a.size())
    TEST_ASSERT_EQUALS(5, b.size())
    TEST_ASSERT_EQUALS(4, c.size())
}

3.9 push_back

void DequeSuite::push_back()
{
    int array[] = { 1, 2, 3, 4, 5 };
    std::deque<int> a;

    for(size_t i = 0; i < ARRAY_SIZE(array); i++)
        a.push_back(array[i]);

    for(size_t i = 0; i < a.size(); i++)
        TEST_ASSERT_EQUALS(array[i],  a[i])
}

3.10 push_front

void DequeSuite::push_front()
{
    int array[] = { 1, 2, 3, 4, 5 };
    std::deque<int> a;
    std::deque<int> b;

    for(size_t i = 0; i < ARRAY_SIZE(array); i++)
        a.push_front(array[i]);

    int index = 0;
    for(auto it = a.crbegin(); it != a.crend(); ++it)
        TEST_ASSERT_EQUALS(array[index++],  *it)
}

说明:

  • 相对vector，deque可以从front插入元素

3.11 pop_back

void DequeSuite::pop_back()
{
    std::deque<int> a({1, 2, 3, 4, 5});

    TEST_ASSERT_EQUALS(5, a.back())

    a.pop_back();
    TEST_ASSERT_EQUALS(4, a.back())
    
    a.pop_back();
    TEST_ASSERT_EQUALS(3, a.back())

    a.pop_back();
    TEST_ASSERT_EQUALS(2, a.back())
    
    a.pop_back();
    TEST_ASSERT_EQUALS(1, a.back())

    a.pop_back();
    TEST_ASSERT_EQUALS(true, a.empty())

    if(!a.empty())
        a.pop_back();//??
    TEST_ASSERT_EQUALS(true, a.empty())
}

3.12 pop_front

void DequeSuite::pop_front()
{
    std::deque<int> a({1, 2, 3, 4, 5});

    TEST_ASSERT_EQUALS(1, a.front())

    a.pop_front();
    TEST_ASSERT_EQUALS(2, a.front())
    
    a.pop_front();
    TEST_ASSERT_EQUALS(3, a.front())

    a.pop_front();
    TEST_ASSERT_EQUALS(4, a.front())
    
    a.pop_front();
    TEST_ASSERT_EQUALS(5, a.front())

    a.pop_front();
    TEST_ASSERT_EQUALS(true, a.empty())

    if(!a.empty())
        a.pop_front();//??
    TEST_ASSERT_EQUALS(true, a.empty())
}

说明:

  • 相对vector，deque可以从front弹出元素

3.13 insert

void DequeSuite::insert()
{
    std::deque<std::string> names;
    std::string name("James");

    auto it = names.insert(names.begin(), name);//James
    TEST_ASSERT_EQUALS(name, *it)

    it = names.insert(names.end(), 2, "Tom"); //James Tom Tom 
    TEST_ASSERT_EQUALS("Tom", *it)

    it = names.insert(names.end(), "Peter"); //James Tom Tom Peter
    TEST_ASSERT_EQUALS("Peter", *it)

    it = names.insert(names.end(), {"Jim", "Rose", }); //James Tom Tom Peter Jim Rose
    TEST_ASSERT_EQUALS("Jim", *it)
}

说明:

  • 返回iterator指向被删除元素的下一位置

3.14 erase

void DequeSuite::erase()
{
    std::deque<int> a({1, 2, 3, 4, 5});
    TEST_ASSERT_EQUALS(5, a.back())
    
    auto it = a.erase(a.begin() + 4);//1, 2, 3, 4

    //a.erase(a.begin() + 5); double free or corruption (out)

    TEST_ASSERT_EQUALS(true, it == a.end())
    TEST_ASSERT_EQUALS(4, a.back())

    it = a.erase(a.begin() + 1, a.begin() + 3);//1, 4
    TEST_ASSERT_EQUALS(4, *it)
    TEST_ASSERT_EQUALS(4, a.back())
}

说明:

  • 传入iterator必须是有效的
  • 返回iterator指向被删除元素的下一位置

3.15 swap

void DequeSuite::swap()
{
    std::deque<int> a({1, 2, 3, 4, 5});
    std::deque<int> b;

    TEST_ASSERT_EQUALS(5, a.size())
    TEST_ASSERT_EQUALS(0, b.size())

    a.swap(b);
    TEST_ASSERT_EQUALS(0, a.size())
    TEST_ASSERT_EQUALS(5, b.size())
}

3.16 clear

void DequeSuite::clear()
{
    std::deque<int> a({1, 2, 3, 4, 5});

    TEST_ASSERT_EQUALS(5, a.size())
    a.clear();

    TEST_ASSERT_EQUALS(0, a.size())
}

3.17 emplace

void DequeSuite::emplace()
{
    std::deque<std::string> names;
    auto it = names.emplace(names.begin(), "james"); //james
    TEST_ASSERT_EQUALS("james", *it)
    it = names.emplace(names.end(), "jim"); //james jim
    TEST_ASSERT_EQUALS("jim", *it)
}

说明:

  • 返回iterator指向被删除元素的下一位置

3.18 emplace_front

void DequeSuite::emplace_front()
{
    std::deque<std::string> names;
    names.emplace_front("james"); //james
    TEST_ASSERT_EQUALS("james", names.front())
    names.emplace_front("jim"); //james jim
    TEST_ASSERT_EQUALS("jim", names.front())
}

说明:

  • 返回iterator指向被删除元素的下一位置

3.19 emplace_back

void DequeSuite::emplace_back()
{
    std::deque<std::string> names;
    names.emplace_back("james"); //james
    TEST_ASSERT_EQUALS("james", names.back())
    names.emplace_back("jim"); //james jim
    TEST_ASSERT_EQUALS("jim", names.back())
}

3.20 get_allocator

void DequeSuite::get_allocator()
{
    std::deque<int> a;
    auto allocator = a.get_allocator();
    int* p = allocator.allocate(5);

    allocator.deallocate(p, 5);
    try
    {
        p = allocator.allocate(allocator.max_size() + 1);
    }
    catch(...)
    {
        p = nullptr;
    }
    TEST_ASSERT_EQUALS(true, p == nullptr)
}
flysnow010
关注
专栏目录
C++--双端队列deque
Iiverson2000的博客
09-16 574
双端队列这个结构 ，总是作为stack和queue容器适配器的默认模板参数类型，它的功能很丰富，头删头插，尾插尾删，随机存取等等，看起来就是vector和list的合体。为什么这么说呢？ 优点 缺点 vector 1.随机访问 2.尾插 头、中部插入删除 list 任意位置插入删除 随机访问 那么在功能上，我们可以清楚的看到 deque = vector+list 真的是这样么？ 结论： 1.deque不能替代vector和list 2.deque采用operator [ ]
c++的双端队列deque
weixin_43293737的博客
03-11 1000
deque 即双端队列。是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。 实例代码 #include "iostream" using namespace std; #include "deque"//双端集合，可以从两头插入数据，并以插入顺序排列 void print(deque&lt;int&gt; baby) { for (dequ...
C++容器——双端队列（deque）
shouhu010的博客
03-13 384
C++ deque 动态数组 初始化 访问元素 修改元素
C++STL初阶（13）：双端队列deque和优先级队列priority_queue(包含详细计算)、仿函数介绍
最新发布
2301_79501467的博客
08-20 760
双开口的含义是：可以在头尾两端进行插入和 删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。尽管名字叫双端队列，但是deque和队列FIFO的特性没有太多关系，我们抛开先进先出的特性进行学习。deque是一个顺序容器（sequence container），而不是容器适配器。
C++ Deque（双端队列）
码农01号的博客
02-16 818
什么Deque? 双端队列表示双端队列。它概括了队列数据结构，即可以从前端或后端的两端进行插入和删除。 Deque和vector区别 vector对于头部的插入和删除效率低,数据量越大,效率越低 deque相对而言,对头部的插入删除速度比vector快 vector访问元素时的速度比deque快 #include "stdafx.h" #include<iostream> #include "deque.h" #include <deque> using namespace
C++ STL之deque双端队列
CSDN_HZW的博客
11-06 597
deque与vector非常相似，不仅可在尾部插入和删除，还可在头部插入和删除，但是内部的数据机制和执行性能与vector不同，一般来说，当考虑到容器元素的内存分配策略和操作的性能时，deque比vector有优势。 技术原理 deque的元素数据采用分块的线性结构进行存储，如下图所示。deque分成若干线性存储块，称为deque块，所以的deque块使用一个Map块进行管理，每个Map数据项...
C++ STL deque(双端队列)-＞单调队列 使用方法
qq_61252495的博客
04-14 1588
为啥能用单调队列做?当时在学习单调队列的时候 我也抱着这样的一个疑惑 ,那这就要从单调队列的性质说起了.std::deque 是 C++ STL 库 提供的一种 双端队列 其。有了上面的一些常用操作,做题也就够用了 ,deque的一种经典应用就是。的窗口 窗口从第一个元素开始向后移动 要求输出每次窗口中的。个单位 然后算出最大值和最小值存到数组里最后再输出。最大值 也是同样的操作方法。个元素和一个 长度为。: 判断队列是否为空。:返回对首元素的值(:返回队尾元素的值(只有两个测数据集没过。
C++中，实现std::deque<std::deque<std::deque<Template T>>>这样的std::deque的多重嵌套，且指定每一重std::deque的大小为固定尺寸，如何实现
07-03
在C++中，`std::deque` 是一种双端队列容器，它允许高效的在两端添加和删除元素。如果你想要创建一个多层嵌套的 `std::deque`，每个内部的 deque 的大小都是固定的，你可以这样做： ```cpp #include <deque> // ...
C++中，实现std::deque<std::deque<std::deque<QImage>>>这样的std::deque的多重嵌套，如何指定外部的deque的数量，如何指定外部deque中存储的内部deque的数量？每一重内部deque的数量不同时，如何指定？
07-03
在C++中，`std::deque` 是一种双端队列容器，它允许在两端高效地添加和删除元素。要创建一个多层嵌套的 `std::deque` 结构，如 `std::deque<std::deque<std::deque<QImage>>>`，你可以这样定义： ```cpp // 指定...
STL中的deque及源码实现 std::deque
我的大学
09-26 7498
本博客中涉及到的所有代码均在我的github上存放，地址：mySTL如果有兴趣的话可以去下载查看，注释比较详尽。说点什么相信大家如果对C++有一定的了解的话，都会知道C++中有STL这个超大的模版库，这个模版库提供了非常多的模版容器和模版算法，如常用的vector、list、stack、queue、map、set等等容器，sort、find_if、find、swap等模版函数 这个库由于创建时间过
C++，创建一个固定大小的std::deque，然后实现这个固定大小的std::deque的三重嵌套，即std::deque内部嵌套std::deque
07-03
在C++中，`std::deque` 是一种双端队列，可以动态调整容量以适应元素的添加或删除。要创建一个固定大小的`std::deque`，你可以直接指定构造函数中的`count`参数。这里有两个版本的构造函数： 1. C++11之前的版本...
STL 双端队列(deque)
szplzx1314的博客
10-02 971
双端队列(deque) deque(double ended queue,双向队列),和向量(vector)类似,可以头部的快速的插入和删除. 同样支持随机访问 其实他和vector差别很少,vector有capacity是容量,deque中没有. deque中有前插前删,vector中没有.在任何标准里其实也没有明确的说明何时何地选他们两个哪一个. 初始化遍历deque #include <iostream> #include <deque> using names
STL双端队列 deque
张驴儿的博客
03-20 397
STL双端队列 deque #include #include #include #include #include using namespace std; /* deque采用一块map(不是STL中的map，是一块连续空间)作为主控， 每个元素都是一个节点(cur fist last node)指向另一段连续较大的空间（成为缓冲区 默认512byte） deque内维持一个map和 来两个
stl容器deque_C ++ STL双端队列容器– std :: deque
culing2941的博客
09-15 326
stl容器dequeHere you will learn about C++ STL Deque container i.e. std::deque and all functions applicable on it. 在这里，您将了解C ++ STL Deque容器，即std :: deque及其适用的所有功能。 Note: Deque should be pronounced as “...
C++实现双端队列(数组模拟)【每一步详细深入讲解，代码清晰、简单、易懂】
weixin_55755506的博客
01-10 4364
如左图，左指针已经到了左边界，但队列还没满按理说应该可以左入队，再次入队之后左指针应该到达最右边，这样才能实现继续入队，现在只要实现左指针到达左边界时再入队，指针移动到最右边的操作。经过思考，发现一个小于B的数A模B依然等于A，而如果A等于B，那A模B就等于0，-1+B模B等于B-1，而A加上任意个B 再模B依然等于A。但是，这样怎么看怎么别扭，左边和右边都执行了入队，但左指针位置无元素，右指针位置却有，而且左右入队操作不同，不太符合通用原则。发现，左边入队是正常，但，右边入队时入队的值覆盖了之前的值！
双端队列（c++）
m0_65690223的博客
04-23 1190
我们首先使用push_front和push_back操作向队列中添加元素，然后使用pop_front和pop_back操作从队列中弹出元素。我们还使用front和back操作来获取队列头部和尾部的元素，并使用empty和size操作来检查队列是否为空，并获取队列中元素的个数。1. push_front(x)：将元素x插入到队列头部。2. push_back(x)：将元素x插入到队列尾部。3. pop_front()：弹出队列头部元素。4. pop_back()：弹出队列尾部元素。
C++的双端队列
lcc1737的博客
03-05 961
C++的双端队列
【C++】deque双端队列
weixin_63449996的博客
01-10 2437
STL容器：deque
C++双端队列
weixin_44614083的博客
05-12 5385
系列文章目录 C++入门 C++类和对象（上） C++类和对象（中） C++类和对象（下） C/C++内存管理 C++string类 C++vector类 C++list类 C++stack和queue 文章目录系列文章目录前言一、dequeue是什么？二、dequeue的优势三、dequeue的缺陷 前言 在介绍双端队列以前先来介绍一下容器适配器 适配器是标准库中的一个通用概念，容器，迭代器，和函数都有适配器。本质上，适配器是一种机制，能使某种事物的行为看起来像是另外一种事物一样。一个容器适配器接受一
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

flysnow010

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

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

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

打赏作者

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

抵扣说明：

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

余额充值