deque容器

原创 2016年08月31日 14:50:06

之前有写到的vector易于做random_access,对于插入涉及到内存重分配,而对于list适合做insert/erase但是对于随机取值只能遍历。

是不是有一种结合两者的做法呢?那就是deque。

deque的实现思路是这样的:

(1)内存的不连续,划分成一段一段的,每段可以存储相同个数的元素。

(2)每段内存存储的地址用一个专门的数组保存起来。

(3)对于随机取值可以直接计算出落在哪段内存区间的哪个位置。(取整和取余运算)

(4)插入元素时,保存指针的数组由于是连续内存区间,所以涉及到重新保存指针数组的内存重新申请和拷贝,相对于元素拷贝代价小。

(5)对于随机插入没能避免元素拷贝。


deque的实现,成员变量是deque的迭代器,所以我们先看迭代器的实现。

template <class _Tp, class _Ref, class _Ptr>
struct _Deque_iterator {
typedef _Tp** _Map_pointer;
 _Tp* _M_cur;            //此段内存迭代器指针
  _Tp* _M_first;         //此段内存首地址
  _Tp* _M_last;          //此段内存end  
  _Map_pointer _M_node;//指针数组的值,标识某一段元素内存
}
迭代器加减预算

  _Self& operator+=(difference_type __n)
  {
    difference_type __offset = __n + (_M_cur - _M_first);
    //_S_buffer_size()表示每段内存容纳多少的元素T  等于__size < 512 ? size_t(512 / __size) : size_t(1)
    if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
      _M_cur += __n;       //在同一段内存区间
    else {
      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);
      _M_cur = _M_first + 
        (__offset - __node_offset * difference_type(_S_buffer_size())); //元素偏移
    }
    return *this;
  }
_Deque_base的实现包含4个重要的成员数据:

  _Tp** _M_map;          //指针数组     
  size_t _M_map_size;    //指针数组大小
  iterator _M_start;     //标识第一个内存段
  iterator _M_finish;    //标识最后一个内存段(这是一个闭合区间,和deque的迭代器_M_last半开区间不一样)
构造_Deque_base:

_Deque_base(const allocator_type&, size_t __num_elements)
    : _M_map(0), _M_map_size(0),  _M_start(), _M_finish() {
    _M_initialize_map(__num_elements);
  }
先把指针数组创建出来吧

template <class _Tp, class _Alloc>
void
_Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements)
{
  size_t __num_nodes = 
    __num_elements / __deque_buf_size(sizeof(_Tp)) + 1;
   //_S_init_map_size=8 加2是为了之后方便push元素
  _M_map_size = max((size_t) _S_initial_map_size, __num_nodes + 2);
  _M_map = _M_allocate_map(_M_map_size);
   //由于是双向表结构,把start放到中间去
  _Tp** __nstart = _M_map + (_M_map_size - __num_nodes) / 2;
  _Tp** __nfinish = __nstart + __num_nodes;
    
  __STL_TRY {
    _M_create_nodes(__nstart, __nfinish);
  }
  __STL_UNWIND((_M_deallocate_map(_M_map, _M_map_size), 
                _M_map = 0, _M_map_size = 0));
  _M_start._M_set_node(__nstart);
  _M_finish._M_set_node(__nfinish - 1); //闭合区间
  _M_start._M_cur = _M_start._M_first;
  _M_finish._M_cur = _M_finish._M_first +
               __num_elements % __deque_buf_size(sizeof(_Tp));//finish的cur指到最后一个元素去(开区间)
}

插入元素

  void push_back(const value_type& __t) {
    if (_M_finish._M_cur != _M_finish._M_last - 1) { //此段内存元素还未满
      construct(_M_finish._M_cur, __t);
      ++_M_finish._M_cur;
    }
    else
      _M_push_back_aux(__t);       //需下一段内存
  }
在下一段内存插入
template <class _Tp, class _Alloc>
void deque<_Tp,_Alloc>::_M_push_back_aux(const value_type& __t)
{
  value_type __t_copy = __t;
  _M_reserve_map_at_back();            //判断是否需要扩充指针数组
  *(_M_finish._M_node + 1) = _M_allocate_node();
  __STL_TRY {
    construct(_M_finish._M_cur, __t_copy);
    _M_finish._M_set_node(_M_finish._M_node + 1);
    _M_finish._M_cur = _M_finish._M_first;
  }
  __STL_UNWIND(_M_deallocate_node(*(_M_finish._M_node + 1)));
}

指针数组重新分配

 void _M_reserve_map_at_back (size_type __nodes_to_add = 1) {
    if (__nodes_to_add + 1 > _M_map_size - (_M_finish._M_node - _M_map)) //没有多余内存段了
      _M_reallocate_map(__nodes_to_add, false);
  }
void deque<_Tp,_Alloc>::_M_reallocate_map(size_type __nodes_to_add,
                                          bool __add_at_front)
{
  size_type __old_num_nodes = _M_finish._M_node - _M_start._M_node + 1;
  size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;

  _Map_pointer __new_nstart;
  if (_M_map_size > 2 * __new_num_nodes) {
    __new_nstart = _M_map + (_M_map_size - __new_num_nodes) / 2 
                     + (__add_at_front ? __nodes_to_add : 0);
    if (__new_nstart < _M_start._M_node)                           //内存重叠问题
      copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);
    else
      copy_backward(_M_start._M_node, _M_finish._M_node + 1, 
                    __new_nstart + __old_num_nodes);
  }
  else {
    size_type __new_map_size = 
      _M_map_size + max(_M_map_size, __nodes_to_add) + 2;          //指针数组重新扩容

    _Map_pointer __new_map = _M_allocate_map(__new_map_size);
    __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
                         + (__add_at_front ? __nodes_to_add : 0);
    copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart); //原值拷贝到新的数组去再释放掉原来的
    _M_deallocate_map(_M_map, _M_map_size);

    _M_map = __new_map;
    _M_map_size = __new_map_size;
  }

  _M_start._M_set_node(__new_nstart);
  _M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
}

随机插入就要命了。。

template <class _Tp, class _Alloc>
void deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos,
                                      size_type __n,
                                      const value_type& __x)

函数实现主要依赖迭代器进行元素拷贝

        uninitialized_copy(_M_start, __start_n, __new_start);
        _M_start = __new_start;
        copy(__start_n, __pos, __old_start);

对于deque的每一句代码实现没有细看,总的思想就是这些

(1)不连续内存,指针拷贝避免元素拷贝

(2)随机取值可直接计算复杂度O(1)

(3)不解决随机插入问题,预分配指针数组空间便于之后的前后push



版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

STL的容器deque的使用

  • 2014-07-20 21:32
  • 28KB
  • 下载

STL中序列式容器之三deque

vector是单向开口的连续线性空间,而deque则是一种双向开口的连续线性空间。所谓双向开口,意思是可以在头尾两端都可以做元素的插入与删除操作。vector当然也可以在头尾两端进行操作(从技术观点)...

STL源码笔记(11)—序列式容器之deque(一)

STL序列式容器之deque简介 deque是一种双向开口的连续线性空间,他可以在常量时间内对头部和尾部进行插入和移除操作。

C++ Primer学习笔记(11)——(转)c++ 标准库的各种容器(vector,deque,map,set,unordered_map,unordered_set,list)的性能考虑

声明:此文章转自truexf 的博客,自觉他总结的比我好,故收藏于此,共学习之用。谢谢大神分享!

c++容器1(vector、list、deque)

http://blog.csdn.net/xfortius/article/details/7760490 vector ,deque 和 list 顺序性容器: 向量 vector :   ...

C++顺序容器vector、deque、list

1、容器元素类型     C++中大多数数据类型可以作为容器的元素类型。容器元素类型必须满足一下两个条件:支持赋值和复制操作。     所以没有元素是引用类型的容器,同时IO对象和auto_ptr...

STL提供了三个最基本的容器:vector,list,deque

vector和built-in数组类似,它拥有一段连续的内存空间,并且起始地址不变,因此它能非常好的支持随机存取,即[]操作符,但由于它的内存空间是连续的,所以在中间进行插入和删除会造成内存块的拷贝,...

ACM学习历程14——deque双端队列容器

Deque双端队列容器与Vector向量容器相似,实现了随机访问、尾部插入和头部插入。不同的是deque采用分块的线性存储结构存储数据,此外,deque内部的数据数据机制和执行性能也与vector不同...

STL容器类vector,list,deque性能的比较

http://hi.baidu.com/shirley_wheat/blog/item/84a3b5f59389eb61dcc47441.html   C++的STL模板库中提供了3种容器类:ve...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)