STL容器-deque-双端队列

最新推荐文章于 2024-04-14 13:56:07 发布
最新推荐文章于 2024-04-14 13:56:07 发布
阅读量163 收藏
点赞数
文章标签： 前端 ViewUI
原文链接：http://www.cnblogs.com/lMonster81/p/10433776.html
版权

注明：全部来自转载，供自己学习与复习使用

 

deque双向开口可进可出的容器

我们知道连续内存的容器不能随意扩充,因为这样容易扩充别人那去

deque却可以,它创造了内存连续的假象.

其实deque由一段一段构成 ,他是分段连续,而不是内存连续 当走向段的尾端时候自动跳到下一段 所以支持迭代器++ 操作,自动跳到下一段的方法由operator++实现

deque每次扩充 申请一个段

一 定义

头文件 #include <deque>

int main_0() {

    //默认构造函数 创建一个空的deque
    deque<int> c;
    
    //拷贝构造
    deque<int> c1(c);
    
    //赋值拷贝
    deque<int> c2 = c1;
    
    //指定元素个数创建
    deque<int> c3 (5,6);
    for (auto i : c3) {
        cout<< i << ",";
    }
    cout << "deque(个数, 元素)"<<endl;
    
    //指定区间创建
    deque<int> c4(c3.begin()+2, c3.begin()+3);
    for (auto i : c4) {
        cout<< i << ",";
    }
    cout << "deque(区间, 区间)"<<endl;
    
    //指定初始化列表创建
    deque<int> c5({2,3,4,5});
    for (auto i : c5) {
        cout<< i << ",";
    }
    cout << "deque({})"<<endl;
    
    //指定初始化列表创建
    deque<int> c6 = {2,3,4,5};
    for (auto i : c6) {
        cout<< i << ",";
    }
    cout << "deque = {}" <<endl;
    cout<<endl;
    return 0;
}

 

二 操作

 

int main()
{
    deque<int> c = {1,2,3,4,5};
    deque<int> c1;
    
    // 赋值初始化
    c1.assign(c.begin(),c.end());
    for (auto i: c1) {
        cout<< i << ",";
    }
    cout << "assign()" <<endl;

    //在尾部插入
    c1.push_back(6);
    for (auto i: c1) {
        cout<< i << ",";
    }
    cout << "push_back()" <<endl;
    
    //头插入
    c1.push_front(0);
    for (auto i: c1) {
        cout<< i << ",";
    }
    cout << "push_front()" <<endl;
    
    //弹尾元素
    c1.pop_back();
    for (auto i: c1) {
        cout<< i << ",";
    }
    cout << "pop_back()" <<endl;
    
    //弹头元素
    c1.pop_front();
    for (auto i: c1) {
        cout<< i << ",";
    }
    cout << "pop_front()" <<endl;
    
    //指定位置插入元素
    c1.insert(c1.begin()+3, 10);
    for (auto i: c1) {
        cout<< i << ",";
    }
    cout << "insert()" <<endl;
    
    //删除指定位置元素
    c1.erase(c1.begin()+3);
    for (auto i: c1) {
        cout<< i << ",";
    }
    cout << "erase()" <<endl;

    //清空deque
    c.clear();
    for (auto i: c) {
        cout<< i << ",";
    }
    cout << "clear()" <<endl;
    
    //构造
    c1.emplace(c1.end(), 100);
    for (auto i: c1) {
        cout<< i << ",";
    }
    cout << "emplace()" <<endl;
    
    //头位置插入元素
    c1.emplace_front(111);
    for (auto i: c1) {
        cout<< i << ",";
    }
    cout << "emplace_front()" <<endl;
    
    //尾位置插入元素
    c1.emplace_back(111);
    for (auto i: c1) {
        cout<< i << ",";
    }
    cout << "emplace_back()" <<endl;
    
    //交换
    c.swap(c1);
    for (auto i: c) {
        cout<< i << ",";
    }
    cout << "swap()" <<endl;
    
    int tmp;
    tmp = c.front();
    cout<<"第一个元素"<< tmp << endl;
    
    tmp = c.back();
    cout<<"最后一个元素"<< tmp << endl;
    
    tmp = c.at(1);
    cout<<"指定下标元素"<< tmp << endl;
    
    tmp = c[1];
    cout<<"指定[]下标元素"<< tmp << endl;

    return 0;
}

 

 

三 内存

int main()
{
    deque<int> c = {1,2,3,4,5};
    
    //元素个数
    cout<< "size(): " << c.size() <<endl;
    
    //重新设定deque大小 少退多补
    c.resize(10, 5);
    for(auto i : c)
    {
        cout << i <<",";
    }
    cout << "resize()" << endl;
    
    //最大容量
    cout << "max_size(): " << c.max_size() <<endl;
    
    //是否为空
    cout << "empty: " << c.empty() << endl;
    
    //清空内存
    c.shrink_to_fit();
    
    return 0;
}

 

 

五 与迭代器操作

int main()
{
    deque<int> c = {1,2,3,4,5};
    //指向第一个元素的迭代器
    cout << *c.begin() << endl;
    //指向最后一个元素的下一个位置的迭代器
    cout << *c.end() << endl;
    //反向deque的第一个元素的迭代器
    cout << *c.rbegin() << endl;
    //反向deque的第一个元素的上一个位置迭代器
    cout << *c.rend() << endl;
    //指向第一个元素的迭代器
    cout << *c.cbegin() << endl;
    //指向最后一个元素的下一个位置的迭代器
    cout << *c.cend() << endl;
    //反向deque的第一个元素的迭代器
    cout << *c.crbegin() << endl;
    //反向deque的第一个元素的上一个位置迭代器
    cout << *c.crend() << endl;
    
    return 0;
}

 

Soource Code

 deque的类图如下,跟vector的类图结构相似

_Deque_base<_Tp>基类

    template<typename _Tp, typename _Alloc>
    class _Deque_base
    {
        ...
        struct _Deque_impl
        : public _Tp_alloc_type
        {
            _Tp** _M_map;
            size_t _M_map_size;
            iterator _M_start;
            iterator _M_finish;
        }
        ...
    }

_Deque_impl<_Tp>数据类

成员变量含义,如下图所示 

_M_map指向存储  指向内存的指针  的连续内存

_M_map_size表示_M_map指向的内存大小(有多少个buffer)

_M_start指向_M_map指向内存起始点的迭代器

_M_finish指向_M_map指向内存结束点的迭代器

deque<_Tp>

    
    template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class deque : protected _Deque_base<_Tp, _Alloc>
    {
        //成员变量含义与vector成员变量含义相似
    public:
        typedef _Tp                                        value_type;
        typedef typename _Tp_alloc_type::pointer           pointer;
        typedef typename _Tp_alloc_type::const_pointer     const_pointer;
        typedef typename _Tp_alloc_type::reference         reference;
        typedef typename _Tp_alloc_type::const_reference   const_reference;
        typedef typename _Base::iterator                   iterator;
        typedef typename _Base::const_iterator             const_iterator;
        typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;
        typedef std::reverse_iterator<iterator>            reverse_iterator;
        typedef size_t                             size_type;
        typedef ptrdiff_t                          difference_type;
        typedef _Alloc                             allocator_type;
        
        ...
        //这个函数返回buffer大小
        static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
        { return __deque_buf_size(sizeof(_Tp)); }
        
    }
    
    //它的实现如下
#ifndef _GLIBCXX_DEQUE_BUF_SIZE
#define _GLIBCXX_DEQUE_BUF_SIZE 512
#endif
    
    inline size_t
    __deque_buf_size(size_t __size)
    { return (__size < _GLIBCXX_DEQUE_BUF_SIZE
        ? size_t(_GLIBCXX_DEQUE_BUF_SIZE / __size) : size_t(1)); }
    /*
     如果是deque<int>的话 上面的函数可以翻译成 4 < 512 ? size_t(512/4) " size_t(1)     
     结果就是512/4 = 128
     那么每个buffer所含value_type的个数就128,即一个buffer能存128个int
     
     deque<double> 的话就是512/8 = 64 那么每个buffer的所含个数就是64
     
     如果>=512 就是每个buffer只能存1个 (class/array/struct)
    */

 

解析一个成员函数insert(),在解析之前介绍一下它的迭代器成员变量的含义

start 指向头的迭代器(_M_start)

finish 指向尾部的下一个位置的迭代器(_M_finish)

cur 指向当前元素

first 指向当前buffer内的第一个元素

last 指向单钱buffer的最后一个元素

node 指向当前buffer的指针

map_size node的个数

     insert(const_iterator __position, value_type&& __x)
     { return emplace(__position, std::move(__x)); }

 

empalce()

     template<typename _Tp, typename _Alloc>
     template<typename... _Args>
     typename deque<_Tp, _Alloc>::iterator
     deque<_Tp, _Alloc>::
     emplace(const_iterator __position, _Args&&... __args)
     {
     if (__position._M_cur == this->_M_impl._M_start._M_cur) //插入的位置是否在最前端
     {
     emplace_front(std::forward<_Args>(__args)...);
     return this->_M_impl._M_start;
     }
     else if (__position._M_cur == this->_M_impl._M_finish._M_cur)//插入的位置在最尾端
     {
     emplace_back(std::forward<_Args>(__args)...);
     iterator __tmp = this->_M_impl._M_finish;
     --__tmp;//迭代器指向的是最尾端的下一个位置
     return __tmp;
     }
     else
     return _M_insert_aux(__position._M_const_cast(),
     std::forward<_Args>(__args)...);
     }

 

 emplace_front()

 template<typename _Tp, typename _Alloc>
     template<typename... _Args>
     void
     deque<_Tp, _Alloc>::
     emplace_front(_Args&&... __args)//插入在最前端
     {
     if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)//如果最前端的buffer内存够的话
     {
     this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1,
     std::forward<_Args>(__args)...);//直接在备用空间上构造元素
     --this->_M_impl._M_start._M_cur;//调整cur
     }
     else //如过内存不够
     _M_push_front_aux(std::forward<_Args>(__args)...);
     }
     
     
     #if __cplusplus >= 201103L
     template<typename... _Args>
     void
     deque<_Tp, _Alloc>::
     _M_push_front_aux(_Args&&... __args)
     #else
     void
     deque<_Tp, _Alloc>::
     _M_push_front_aux(const value_type& __t)
     #endif
     {
     _M_reserve_map_at_front();
     *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();//申请空的头结点
     __try
     {
     this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
     - 1); //改变start，令其指向新节点
     this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1; 改变cur，
     #if __cplusplus >= 201103L
     this->_M_impl.construct(this->_M_impl._M_start._M_cur,
     std::forward<_Args>(__args)...);//复制
     #else
     this->_M_impl.construct(this->_M_impl._M_start._M_cur, __t);
     #endif
     }
     __catch(...)
     {
     ++this->_M_impl._M_start;
     _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
     __throw_exception_again;
     }
     }

_M_insert_aux

#if __cplusplus >= 201103L
     template<typename... _Args>
     typename deque<_Tp, _Alloc>::iterator
     deque<_Tp, _Alloc>::
     _M_insert_aux(iterator __pos, _Args&&... __args)
     {
     value_type __x_copy(std::forward<_Args>(__args)...); // XXX copy
     #else
     typename deque<_Tp, _Alloc>::iterator
     deque<_Tp, _Alloc>::
     _M_insert_aux(iterator __pos, const value_type& __x)
     {
     value_type __x_copy = __x; // XXX copy
     #endif
     difference_type __index = __pos - this->_M_impl._M_start;//重在operator- 返回距起始端距离 安插点之前的元素个数
     if (static_cast<size_type>(__index) < size() / 2)//若果插入点在整体内存的前半段,插入后整体内存前移
     {
     push_front(_GLIBCXX_MOVE(front()));//复制头buffer的一个元素
     iterator __front1 = this->_M_impl._M_start;//取出头迭代器位置,和下一个节点的起始点
     ++__front1;
     iterator __front2 = __front1;
     ++__front2;
     __pos = this->_M_impl._M_start + __index;
     iterator __pos1 = __pos;
     ++__pos1;
     _GLIBCXX_MOVE3(__front2, __pos1, __front1);//front1 到 front2 这段区间内的前pos1个元素向前移动一个单位 (留出一个单位给将插入的的元素)
     }
     else
     {
     push_back(_GLIBCXX_MOVE(back()));
     iterator __back1 = this->_M_impl._M_finish;
     --__back1;
     iterator __back2 = __back1;
     --__back2;
     __pos = this->_M_impl._M_start + __index;
     _GLIBCXX_MOVE_BACKWARD3(__pos, __back2, __back1);
     }
     *__pos = _GLIBCXX_MOVE(__x_copy); //复制元素
     return __pos;
     }

 

既然说deque是模仿内存连续,实现这种功能的主要功臣是deque的迭代器,说道迭代器 那么我们一定会联想到迭代器的操作符重载,下面我主要介绍迭代器的操作符重载

operator* 这个比较好理解 返回cur指向的元素

        reference
        operator*() const _GLIBCXX_NOEXCEPT
        { return *_M_cur; }
        
        pointer
        operator->() const _GLIBCXX_NOEXCEPT
        { return _M_cur; }

 

 

operator++()(前++)与operator++(int)

        _Self&
        operator++() _GLIBCXX_NOEXCEPT
        {
            ++_M_cur;
            if (_M_cur == _M_last)//如果++到达该节点尾端
      {
          _M_set_node(_M_node + 1);//跳至下一个节点
          _M_cur = _M_first;
      }
            return *this;
        }
        
        _Self
        operator++(int) _GLIBCXX_NOEXCEPT
        {
            _Self __tmp = *this;
            ++*this;//调用前++
            return __tmp;
        }

 

 

 

operator--()与operator--(int)

        _Self&
        operator--() _GLIBCXX_NOEXCEPT
        {
            if (_M_cur == _M_first)//如果--后到达头端
      {
          _M_set_node(_M_node - 1);//跳至前一个节点
          _M_cur = _M_last;
      }
            --_M_cur;
            return *this;
        }
        
        _Self
        operator--(int) _GLIBCXX_NOEXCEPT
        {
            _Self __tmp = *this;
            --*this;
            return __tmp;
        }

 

 

operator+=(itn) ,+,-=,-

    
        _Self&
        operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
        {
            const difference_type __offset = __n + (_M_cur - _M_first);//查找位置
            if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))//查找位置是否小于一个buffer的容量(在当前buffer内)
                _M_cur += __n;
            else
      {
          const difference_type __node_offset =
          __offset > 0 ? __offset / difference_type(_S_buffer_size())
          : -difference_type((-__offset - 1)
                             / _S_buffer_size()) - 1;
          _M_set_node(_M_node + __node_offset);//切换至正确buffer
          _M_cur = _M_first + (__offset - __node_offset
                               * difference_type(_S_buffer_size()));
      }
            return *this;
        }
        
        _Self
        operator+(difference_type __n) const _GLIBCXX_NOEXCEPT
        {
            _Self __tmp = *this;
            return __tmp += __n;//调用+=
        }
        
        _Self&
        operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
        { return *this += -__n; }//调用+=
        
        _Self
        operator-(difference_type __n) const _GLIBCXX_NOEXCEPT
        {
            _Self __tmp = *this;
            return __tmp -= __n;
        }

 

operator[],和_M_set_node

        
        reference
        operator[](difference_type __n) const _GLIBCXX_NOEXCEPT
        { return *(*this + __n); }
        
        /**
         *  Prepares to traverse new_node.  Sets everything except
         *  _M_cur, which should therefore be set by the caller
         *  immediately afterwards, based on _M_first and _M_last.
         */
        void
        _M_set_node(_Map_pointer __new_node) _GLIBCXX_NOEXCEPT//切换至正确buffer
        {
            _M_node = __new_node;
            _M_first = *__new_node;
            _M_last = _M_first + difference_type(_S_buffer_size());
        }

 

原文出处：

http://www.cnblogs.com/LearningTheLoad/p/7450948.html

 

转载于:https://www.cnblogs.com/lMonster81/p/10433776.html

Ha12312
关注
C++基础-STL deque（双端队列）
编程小鹏的博客
04-16 419
deque双端队列
STL 双端队列(deque)
szplzx1314的博客
10-02 983
双端队列(deque) deque(double ended queue,双向队列),和向量(vector)类似,可以头部的快速的插入和删除. 同样支持随机访问 其实他和vector差别很少,vector有capacity是容量,deque中没有. deque中有前插前删,vector中没有.在任何标准里其实也没有明确的说明何时何地选他们两个哪一个. 初始化遍历deque #include <iostream> #include <deque> using names
python基础（deque双端队列）
jamfiy的博客
03-05 6214
双端队列 在需要按添加元素的顺序进行删除时，双端队列很有用。在模块collections中，包含类型deque以及其他几个集合（collection）类型。 与集合（set）一样，双端队列也是从可迭代对象创建的，它包含多个很有用的方法。 A=deque([]) #创建一个空的双队列 A.append(n) #从右边像队列中增加元素 ，n表示增加的元素 A.appendleft(n) #...
deque
weixin_30535913的博客
08-02 123
转自：https://www.cnblogs.com/LearningTheLoad/p/7450948.html deque双向开口可进可出的容器 我们知道连续内存的容器不能随意扩充,因为这样容易扩充别人那去 deque却可以,它创造了内存连续的假象. 其实deque由一段一段构成 ,他是分段连续,而不是内存连续 当走向段的尾端时候自动跳到下一段 所以支持迭代器++ 操作,自动跳到下...
Java 集合深入理解（10）：Deque 双端队列
weixin_34419326的博客
10-19 1494
点击查看 Java 集合框架深入理解 系列， - ( ゜- ゜)つロ 乾杯~ 什么是 Deque Deque 是 Double ended queue (双端队列) 的缩写,读音和 deck 一样，蛋壳。 Deque 继承自 Queue,直接实现了它的有 LinkedList, ArayDeque, ConcurrentLinkedDeque 等。 ...
双端队列(Deque)
热门推荐
Hacket_Xu的博客
11-05 1万+
deque，即双端队列(double ended queue)，是一种可以在两端扩展或收缩的序列化容器。deque是C++ 标准模板库的一部分，想要使用deque，需要在程序中包含头文件deque。规定了deque中可以存放哪种类型的元素。为deque名。
STL的Deque介绍
dianyimo9099的博客
09-24 150
Deque是双端队列，在画动态图表的时候使用起来比较方便。因为当数据填满图表后，需要从队列的后方插入一个元素，然后再从队列的前方删除一个元素。使用Deque可以很方便的做到。使用push(pop)-back(front)就ok了 下面摘录了一个Deque的使用教程 /*deque: 是一个double-ended queue, 1)支持随即存取，也就是[]操作符，...
C++顺序容器-deque双端队列容器
readyone的博客
12-07 396
c++中deque容器的基本操作：插入、删除、赋值、初始化、存取
253-C++ STL deque 双端队列
weixin_45964837的博客
03-13 682
1.双端队列 双端队列就是两端都可以进行入队和出队，既可以在头部插入和删除数据，也可以在尾部插入和删除数据 2.双端队列中在面试中问的比较多 面试会问：双端队列是如何设计的？ 3.双端队列在内存中是如何布局的？ 有两个迭代器start和finish，每个迭代器中都有cur指针指向下一次插入数据的位置，first指针指向缓冲块的第一个元素(不管有没有数据都是指向第一个位置)，last指针指向缓冲块的最后一个元素(不管有没有数据都是指向最后一个位置)，node指针指向当前缓冲块节点，start迭代器指向所有缓
C++ STL deque(双端队列)-＞单调队列 使用方法
最新发布
qq_61252495的博客
04-14 1601
为啥能用单调队列做?当时在学习单调队列的时候 我也抱着这样的一个疑惑 ,那这就要从单调队列的性质说起了.std::deque 是 C++ STL 库 提供的一种 双端队列 其。有了上面的一些常用操作,做题也就够用了 ,deque的一种经典应用就是。的窗口 窗口从第一个元素开始向后移动 要求输出每次窗口中的。个单位 然后算出最大值和最小值存到数组里最后再输出。最大值 也是同样的操作方法。个元素和一个 长度为。: 判断队列是否为空。:返回对首元素的值(:返回队尾元素的值(只有两个测数据集没过。
STL顺序容器之deque双端队列
AJIOY的专栏
03-27 2523
deque同vector一样也是顺序容器。它内部拥有更复杂的数据结构，从deque队列的两端插入和删除元素都非常快，在容器中间插入或删除则需要付出的代价非常高。 deque的绝大部分操作与vector一致，如支持各种构造方式，push_back，insert，size，resize，empty，capacity等各种vector所支持的操作。并支持push_front(),pop_front()
【Deque】双端队列
liuwanqing233333的博客
09-13 417
双端队列
双端队列Deque
yiqiu1959的博客
12-01 420
双端队列可以当作栈，也可以当作队列，区别在于你添加元素时使用的方法 如果你使用push方法添加元素， 就会以栈的方式存取元素 如果你使用offer方法添加元素， 就会以队列的方式存取元素 Deque stack = new ArrayDeque(); stack： push 和 pop queue： offer和 poll 通用的，即二者都可以用的：add、remove ...
Deque双端队列
weixin_45844836的博客
04-17 201
最近在使用单调栈解决leedcode一些算法题的时候，发现自己对deque 使用有些不规范
STL—deque(双端队列)
dark_cy的博客
03-17 261
简述deque的使用方法和简单函数操作
STL（四） deque 双端队列
程序猿的视界
11-30 1298
deque 底层数据结构 vector是单向开口的线性连续空间，deque则是一种双向开口的连续数据空间。所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作。当然vector也可以在头尾两端进行操作，但是其头部操作效果奇差，所以标准库没有为vector提供push_front或pop_front操作。与vector类似，deque支持元素的快速随机访问。deque的示意图如
队列，双端队列（deque）
soberman的专栏
03-10 570
Deque双端队列容器
hopegrace的博客
02-02 392
Deque双端队列容器 一、基本原理 deque的元素数据采用分块的线性结构进行存储，如图所示。deque分成若干线性存储块，称为deque块。块的大小一般为512个字节，元素的数据类型所占用的字节数，决定了每个deque块可容纳的元素个数。 所有的deque块使用一个Map块进行管理，每个Map数据项记录各个deque块的首地址。Map是deque的中心部件，将先于deque块，依...
C++ deque详解：STL双端队列的全面指南
在C++标准模板库（STL）中，双向队列被实现为`std::deque`，它提供了高效且灵活的队列管理。 `#include <deque>`是使用双向队列的必要头文件，`deque`类继承自容器适配器`container_adaptor`，并支持动态数组的行为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值