从头到尾实现deque

关于deque内部数据结构的说明：
deque是能够同时在收尾进行插入和删除的数据结构。其表现形式看起来和vector差不多，但是在处理队头插入时，其表现的时间复杂度要远远地优越于vector。这个得益于deque的内部数据结构地实现。deque使用分段的连续空间组成。为了管理这个分段的连续空间，所以必须要有一个中控器来记录各个分段空间的首地址，然后需要一个长度来记录该中控器的大小。为了表现和vector相似，所以需要包含2个迭代器分别用来指向首尾元素。关于迭代器的内存元素：首先要有一个指针指向我们待表示的数据。然后就是该数据在那一个缓冲区上，为了在外面上表现为连续的空间，我们必须要记录该缓冲区的首尾地址，这样重载++的时候，能够方便的找到下一块地址。

其结构示意图如下：

其代码实现如下：

//deque的特性:（这段话中别人那copy过来的，因为感觉写的还不错）//   对于任何一个迭代器i//     i.node是map array中的某元素的地址. i.node的内容是一个指向某个结点的头的指针//     i.first == *(i.node)//     i.last  == i.first + node_size//     i.cur是一个指向[i.first, i.last)之间的指针//       注意: 这意味着i.cur永远是一个可以解引用的指针,//            即使其是一个指向结尾后元素的迭代器////   起点和终点总是非奇异(nonsingular)的迭代器.//     注意: 这意味着空deque一定有一个node, 而一个具有N个元素的deque//          (N是Buffer Size)一定有有两个nodes////   对于除了start.node和finish.node之外的每一个node, 每一个node中的元素//   都是一个初始化过的对象. 如果start.node == finish.node,//   那么[start.cur, finish.cur)都是未初始化的空间.//   否则, [start.cur, start.last)和[finish.first, finish.cur)都是初始化的对象,//   而[start.first, start.cur)和[finish.cur, finish.last)是未初始化的空间////   [map, map + map_size)是一个合法的非空区间//   [start.node, finish.node]是内含在[map, map + map_size)区间的合法区间//   一个在[map, map + map_size)区间内的指针指向一个分配过的node,//   当且仅当此指针在[start.node, finish.node]区间内#ifndef ITERATOR_DEQUE_H_INCLUDED#define ITERATOR_DEQUE_H_INCLUDED#include"my_iterator_base.h"namespace juine{     //用来决定缓存区的大小    inline size_t __deque_buf_size(size_t n, size_t sz)    {        return n!=0?n:(sz<512?size_t(512/sz):size_t(1));    }    template<class T,size_t buf_size=0>    class Iterator_deque    {    public:        typedef T value_type;        typedef value_type* pointer;        typedef value_type& reference;        typedef ptrdiff_t difference_type;        typedef random_access_iterator_tag iterator_category;        typedef T** map_pointer;        pointer data;  //所要表示节点的位置        pointer first;  //所在分区的起始位置        pointer last;   //所在分区的末尾位置        map_pointer node;  //所在分区    public:        size_t buff_size() {  return __deque_buf_size(buf_size,64); }        //设定节点的位置        void set_node(map_pointer new_node)        {            node=new_node;            first=0;            last=0;            if(new_node!=0)            {                first=*new_node;                last=*new_node+difference_type(buff_size()); //表明又是左闭右开区间            }        }        //construct        Iterator_deque(pointer _data=0,map_pointer _node=0):data(_data){    set_node(_node);  }        Iterator_deque(const Iterator_deque& iter):data(iter.data),first(iter.first),last(iter.last),node(iter.node){}        Iterator_deque& operator=(const Iterator_deque& iter)        {            data=iter.data;            first=iter.first;            last=iter.last;            node=iter.node;            return *this;        }        //重载解引用,==,!=        reference operator*() { return *data;}        pointer operator->()  { return &(operator*());}        bool operator==(Iterator_deque iter){ return data==iter.data;}        bool operator!=(Iterator_deque iter){ return data!=iter.data; }        bool operator<=(Iterator_deque iter)        {            if(node==iter.node)                return data<=iter.data;            return node<=iter.node;        }        //随机迭代器必须重载++,--        Iterator_deque operator++()        {            data++;            if(data==last)            {                set_node(node+1);                data=first;            }            return *this;        }        Iterator_deque operator++(int)   //后置式的标准写法        {            Iterator_deque iter=*this;            ++*this;            return iter;        }        Iterator_deque operator--()        {            if(data==first)            {                set_node(node-1);                data=last;   //左闭右开            }            data--;            return *this;        }        Iterator_deque operator--(int)        {            Iterator_deque iter=*this;            --*this;            return iter;        }////////////////////////////////////////////////////////////////////////////////// 将迭代器向前移动n个元素, n可以为负//////////////////////////////////////////////////////////////////////////////////                     operator+=(difference_type n)//                                   ↓//                      offset = n + (cur - first)//                                   |//                                   |---------- offset > 0 ? &&//                                   |           移动后是否超出当前缓冲区?//               ----------------------------//           No  |                          |  Yes//               |                          |//               ↓                          |---------- offset > 0?//           cur += n;                      |//                              ----------------------------//                          Yes |                          | No//                              |                          |//                              ↓                          |//                   计算要向后移动多少个缓冲区                |//                   node_offset =                         |//                   offset / difference_type              |//                   (buffer_size());                      ↓//                              |           计算要向前移动多少个缓冲区//                              |           node_offset = -difference_type//                              |           ((-offset - 1) / buffer_size()) - 1;//                              |                          |//                              ----------------------------//                                           |//                                           |//                                           ↓//                                       调整缓冲区//                              set_node(node + node_offset);//                                    计算并调整cur指针////////////////////////////////////////////////////////////////////////////////    // 以下实现随机存取。迭代器可以直接跳跃n个距离        Iterator_deque operator+=(difference_type n)        {            difference_type offset=n+(data-first);            if(offset>=0&&offset<difference_type(buff_size()))               //目标位置在同一个缓冲区内                data+=n;            else            {                //目标位置不在同一个缓冲区中                difference_type node_offset=                offset>0?offset/difference_type(buff_size()):-difference_type((-offset-1)/buff_size())-1;                //切换所在缓冲区                set_node(node+node_offset);                //切换所在目录                data=first+(offset-node_offset*difference_type(buff_size()));            }            return *this;        }        Iterator_deque operator+(size_t n)        {            Iterator_deque iter=*this;            return iter+=n;        }        /*        自己写的，发现效率还是比STL的低,而且STL中是将其+=，-=一起处理的        Iterator_deque operator-=(size_t n)        {            if(size_t(data-first)>=n)                data-=n;            else            {                //表示已经越界了该缓存区。                set_node(node-1);                n-=data-first;                data=last;                while(n>buff_size())                {                    set_node(node-1);                    n-=buff_size();                    data=last;                }                data-=n;            }            return *this;        }*/        Iterator_deque operator-=(size_t n)  {  return *this+=-n;}        Iterator_deque operator-(size_t n)        {            Iterator_deque iter=*this;            iter-=n;            return iter;        }        difference_type operator-(Iterator_deque iter)        {            difference_type offet=(node==iter.node)?data-iter.data:((data-first)+(iter.last-iter.data));            if(node-iter.node>1)                offet+=(node-iter.node-1)*buff_size();            return offet;        }    };}#endif // ITERATOR_DEQUE_H_INCLUDED

容器deque代码如下：

#ifndef MY_DEQUE_H_INCLUDED#define MY_DEQUE_H_INCLUDED#include"iterator_deque.h"#include<algorithm>#include<cstdlib>#include"simple_allocator.h"using std::cout;using std::endl;namespace juine{    template<class T,class Alloc=my_alloc,size_t buf_size=0>    class my_deque    {    public:        typedef T value_type;        typedef T* pointer;        typedef T& reference;        typedef size_t size_type;        typedef T** map_pointer;        typedef simple_allocator<T,Alloc>  data_container;        typedef simple_allocator<pointer,Alloc>  map_container;        typedef Iterator_deque<T,buf_size> iterator;    protected:        size_t map_size;    //申请map_node节点个数，再根据_map能获得map_node的尾节点        map_pointer _map;   //_map是申请的map_node节点的首地址        iterator start;        iterator finish;        size_t buff_size() {  return __deque_buf_size(buf_size,64); }        size_type initial_map_size() {    return 8 ;}        //构造函数时，将deque的结构安排好,初始化deque数据结构        void set_null(map_pointer first,map_pointer last)        {            //map节点是用来保存缓冲区地起始地址，            //但是占为使用的map节点应该保存NULL            map_pointer cur;            for(cur=first;cur<last;cur++)                *cur=NULL;        }        void create_map_and_nodes(size_t n)        {            cout<<"buff_size:"<<buff_size()<<endl;            size_type num_nodes=n/buff_size()+1;//当整除时也是要加1的            //map中控器的大小            //map_size=std::max(initial_map_size(),num_nodes+2);            //为了测试，map_size特殊化            map_size=num_nodes;            _map=map_container::alloc(map_size);            //以下是令nstart和nfinish指向map所拥有之全部节点的最中央区段            //保持在最中央，可使头尾两端扩充的能量一样大，每一节点可对应一个缓冲区            //（出现这种情况是因为，我们申请的节点数，是大于初始化时所需要的节点数，            //因此，需要将节点移动中间，使首尾平衡）            map_pointer nstart=_map+(map_size-num_nodes)/2;            map_pointer nfinish=nstart+num_nodes-1;            //申请缓冲区空间，申请节点为刚才所找到的平衡位置            map_pointer cur;            //申请到的node，暂时不指向缓冲区的应该将其值为NULL            set_null(_map,nstart);            set_null(nfinish,_map+map_size);            for(cur=nstart;cur<=nfinish;cur++)                *cur=data_container::alloc(buff_size());            //接下来是配置迭代器start，finish            start.set_node(nstart);            finish.set_node(nfinish);            start.data=*nstart;            finish.data=*nfinish+n%buff_size();        }        void fill_uninitialized()        {            //默认设定20个指针            _map=map_container::alloc(20);            map_size=20;        }        void fill_uninitialized(size_t n,value_type value)        {            //构造deque时，首先是产生deque的结构并安排组织好            create_map_and_nodes(n);            /*            以下注释部分自己写的，考虑不充分：自己强制规定map的大小，            当所需数据刚好为buf_size时，处理地方式也与STL不一样            _map=map_container::alloc(20);            map_size=20;            map_pointer temp=_map;            int remainder=n%buf_size;            int num=(remainder==0?n/bufsize:(n/buf_size+1));            while(num)            {                pointer p=data_container::alloc(buf_size);                if(num==1)                    uninitialized_fill_n(p,remainder==0?buf_size:remainder,value);  //最后一组只能填充remainder个元素                else                    uninitialized_fill_n(p,buf_size,value);                num--;                *temp=p; //将容器整个结构连接起来                temp++;            }            //对迭代器first,last进行初始化            iterator temp(*_map,*_map,*_map+buf_size-1,_map);            first=temp;            if(remainder!=0)            {                iterator temp1(*(_map+n/buf_size)+remainder-1,*(_map+n/buf_size),*(_map+n/buf_size)+remainder-1,_map+n/buf_size );                last=temp1;            }            else            {                iterator temp1(*(_map+n/buf_size-1)+buf_size-1,*(_map+n/buf_size),*(_map+n/buf_size-1)+buf_size-1,_map+n/buf_size-1 );                last=temp1;            }*/            //开始对申请到的节点进行初始化            map_pointer cur;            for(cur=start.node;cur<finish.node;cur++)                uninitialized_fill_n(*cur,buff_size(),value);            uninitialized_fill_n(finish.first,n%buff_size(),value);        }        template<class InputIterator>        void fill_uninitialized(InputIterator first,InputIterator last)        {            size_type num=last-first;            create_map_and_nodes(num);            //deque结构体已构造好，然后需要赋值            iterator iter=start;            while(first!=last)            {                construct(iter.data,*first);                iter++;                first++;            }        }        //释放内存        void dealloc()        {            cout<<"deque容器已释放"<<endl;            //先遍历map释放所有缓冲区            size_t i;            for(i=0;i<map_size;i++)                if(*(_map+i))   //当节点值为空时，表示其所指向缓冲区为空，不需要释放                {                    map_pointer temp=_map+i;                    destroy(*temp,*temp+buff_size());                    data_container::dealloc(*(_map+i));                }            //删除_map            map_container::dealloc(_map);        }    public:        //construct        my_deque(){    fill_uninitialized();}        my_deque(size_t n,value_type value) { fill_uninitialized(n,value);}        template<class InputIterator>        my_deque(InputIterator first,InputIterator last){ fill_uninitialized(first,last);}        ~my_deque(){ dealloc() ;}        iterator begin(){   return start; }        iterator end(){     return finish; }        reference operator[](size_type n)        {            iterator iter=start+n;            return *iter;        }        reference at(size_type n)        {            iterator iter=start+n;            if(finish<=iter)            {                cout<<"out of memory"<<endl;                exit(1);            }            return iter;        }        reference front(){  return *start; }        reference back(){   return *(finish-1); }        size_type size() {  return finish-start; }        bool empty(){   return start==finish; }        void push_front(value_type value){  insert(start,value); }        void push_back(value_type value){   insert(finish,value);}        //插入函数（考虑缓冲区大小够不，Map大小够不，还有效率-左移还是右移）        void insert(iterator position,value_type value)        {            if(position-start<=finish-position)  //表示需要左移动            {                iterator temp,new_start;                temp=new_start=insert_aux_left(1,position);                iterator temp1=start;                //这个地方赋值，利用了迭代器重载函数++,使其能够自动在片段连续空间上移动                while(temp1!=position)  //移动元素                    *temp++=*temp1++;                *temp=value;  //最后插入元素                start=new_start;   //插入之后，迭代器要更新，Temp保存的就是最新的位子            }            else            {                iterator temp,new_finish;                temp=new_finish=insert_aux_right(1,position);                iterator temp1=finish;                //这个地方赋值，利用了迭代器重载函数++,使其能够自动在片段连续空间上移动                while(temp1!=position)  //移动元素                    *--temp=*--temp1;                *position=value;  //最后插入元素                finish=new_finish;   //插入之后，迭代器要更新，Temp保            }        }        template<class InputIterator>        void insert(iterator position,InputIterator first,InputIterator last)        {            int n=last-first;            if(position-start<=finish-position)  //表示需要左移动            {                iterator temp,new_start;                temp=new_start=insert_aux_left(n,position);                iterator temp1=start;                //这个地方赋值，利用了迭代器重载函数++,使其能够自动在片段连续空间上移动                while(temp1!=position)  //移动元素                    *temp++=*temp1++;                while(temp!=position)                    *temp++=*first++;  //最后插入元素                start=new_start;            }            else            {                iterator temp,new_finish;                temp=new_finish=insert_aux_right(n,position);                iterator temp1=finish;                //这个地方赋值，利用了迭代器重载函数++,使其能够自动在片段连续空间上移动                while(temp1!=position)  //移动元素                    *--temp=*--temp1;                while(first!=last)                    *position++=*first++;  //最后插入元素                finish=new_finish;            }        }        //该函数功能：如容量不够，则扩充容量然后更新该deque结构        //该函数返回值，是表示在插入后，start迭代器所在正确位置        iterator insert_aux_left(size_t number,iterator& position)    //number表示插入的数据,而且该数据是左移的。        {            iterator result;            if(start.data-number<=start.first-1)  //表示前端缓冲区已满,因此要增加缓冲区            {                //要增加的缓冲区                int left_need_size=number-(start.data-start.first);                int need_map_nodes=left_need_size/buff_size()+1;                if(start.node-_map<need_map_nodes)  //表示中控器前端node节点不够了                {                    //虽然前面的不够，但是整个_map空余空间够，可以通过移动_map节点来实现                    //不用重新分配新的节点。                    if(size_t(finish.node-start.node+1+need_map_nodes)<=map_size)                    {                        cout<<"移动map达到要求"<<endl;                       //offset为map移动偏移量                        int offset=need_map_nodes-(start.node-_map);                        map_pointer temp=finish.node;                        while(temp>=start.node)                        {                            *(temp+offset)=*temp;                            temp--;                        }                        //前面_map移动后，finish中所存的Node，已经不是最后一个节点所在位置                        //故要移动，更新finish                        finish.node=finish.node+offset;                        //map前端node节点已够用，现在是要申请缓冲区内存                        map_pointer malloc_node=_map;                        while(malloc_node<(start.node+offset))                        {                            *malloc_node=data_container::alloc(buff_size());                            malloc_node++;                        }                        result.set_node(_map);                        result.data= *_map+buff_size()-left_need_size%buff_size();                    }                    else //map节点不够，需要重新分配其map_nodea                    {                        //map大小，简单以2倍来扩充                        map_pointer new_malloc_map=map_container::alloc(map_size*2);                        map_pointer item=new_malloc_map+map_size/2;                        map_pointer old_node=start.node;                        set_null(new_malloc_map,item);                        set_null(new_malloc_map+map_size,new_malloc_map+map_size*2);                        //将旧的map复制过来                        while(old_node<=finish.node)                            *item++=*old_node++;                        //因为map重新申请了，所以position也应该换到新map对应的位置上                        position.node=new_malloc_map+map_size/2+(position.node-start.node);                        //删除旧的map，释放内存                        map_container::dealloc(_map);                        start.node=new_malloc_map+map_size/2;                        finish.node=item-1;                        _map=new_malloc_map;                        map_size*=2;                         //需要申请内存                        map_pointer new_node=start.node-1;                        while(new_node>=start.node-need_map_nodes)                        {                            *new_node=data_container::alloc(buff_size());                            new_node--;                        }                        result.set_node(start.node-need_map_nodes);                        result.data= *result.node+buff_size()-left_need_size%buff_size();                    }                }                else //缓冲区不够，但是map前端所需node是够的                {                    //需要申请内存                    map_pointer new_node=start.node-1;                    while(new_node>=start.node-need_map_nodes)                    {                        *new_node=data_container::alloc(buff_size());                        new_node--;                    }                    result.set_node(start.node-need_map_nodes);                    result.data= *result.node+buff_size()-left_need_size%buff_size();                }            }            else //缓冲区是够的            {                result.data=start.data-number;                result.set_node(start.node);            }            return result;        }        iterator insert_aux_right(size_t number,iterator& position)    //number表示插入的数据,而且该数据是右移的。        {            iterator result;            if(finish.data+number>=finish.last)  //表示前端缓冲区已满,因此要增加缓冲区            {                //要增加的缓冲区                int left_need_size=number-(finish.last-finish.data-1);                int need_map_nodes=left_need_size/buff_size()+1;                if(_map+map_size-finish.node<need_map_nodes)   //表示中控器后端node节点不够了                {                    //虽然前面的不够，但是整个_map空余空间够，可以通过移动_map节点来实现                    //不用重新分配新的节点。                    if(size_t(finish.node-start.node+1+need_map_nodes)<=map_size)                    {                        cout<<"移动map达到要求"<<endl;                        //offset为map移动偏移量                        int offset=need_map_nodes-(_map-finish.node);                        map_pointer temp=start.node;                        while(temp<=finish.node)                        {                            *(temp-offset)=*temp;                            temp++;                        }                        //前面_map移动后，finish中所存的Node，已经不是最后一个节点所在位置                        //故要移动，更新finish                        start.node=start.node-offset;                        //map前端node节点已够用，现在是要申请缓冲区内存                        map_pointer malloc_node=_map+map_size;                        while(malloc_node>(finish.node-offset))                        {                            *malloc_node=data_container::alloc(buff_size());                            malloc_node--;                        }                        result.set_node(_map+map_size);                        result.data= *(_map+map_size)+left_need_size%buff_size();                    }                    else //map节点不够，需要重新分配其map_nodea                    {                        //map大小，简单以2倍来扩充                        map_pointer new_malloc_map=map_container::alloc(map_size*2);                        map_pointer item=new_malloc_map+map_size/2;                        map_pointer old_node=start.node;                        set_null(new_malloc_map,item);                        set_null(new_malloc_map+map_size,new_malloc_map+map_size*2);                        //将旧的map复制过来                        while(old_node<=finish.node)                            *item++=*old_node++;                        //因为map重新申请了，所以position也应该换到新map对应的位置上                        position.node=new_malloc_map+map_size/2+(position.node-start.node);                        //删除旧的map，释放内存                        map_container::dealloc(_map);                        start.node=new_malloc_map+map_size/2;                        finish.node=item-1;                        _map=new_malloc_map;                        map_size*=2;                         //需要申请内存                        map_pointer new_node=finish.node+1;                        while(new_node<=finish.node+need_map_nodes)                        {                            *new_node=data_container::alloc(buff_size());                            new_node++;                        }                        result.set_node(finish.node+need_map_nodes);                        result.data= *result.node+left_need_size%buff_size();                    }                }                else //缓冲区不够，但是map前端所需node是够的                {                    //需要申请内存                    map_pointer new_node=finish.node+1;                    while(new_node<=finish.node+need_map_nodes)                    {                        *new_node=data_container::alloc(buff_size());                        new_node++;                    }                    result.set_node(finish.node+need_map_nodes);                    result.data= *result.node+left_need_size%buff_size();                }            }            else //缓冲区是够的            {                result.data=finish.data+number;                result.set_node(finish.node);            }            return result;        }        //删除元素（为了简单，只写一种）        void erase(iterator position)        {            iterator temp;            if(position-start<=finish-position)  //左边的元素右移动            {                temp=position-1;                while(start<=temp)                {                    *(temp+1)=*temp;                    temp--;                }                start++;                if((start-1).node!=start.node)                    *(start-1).node=NULL;            }            else            {                temp=position+1;                while(temp!=finish)                {                    *(temp-1)=*temp;                    temp++;                }                finish--;                if((finish+1).node!=finish.node)                    *(finish+1).node=NULL;            }        }        void pop_back(){ erase(finish-1);}        void pop_front(){ erase(start);   }    };}#endif // MY_DEQUE_H_INCLUDED

测试代码如下：

#include<iostream>#include<cstdlib>#include<vector>#include"my_deque.h"using namespace std;using namespace juine;int main(){    int a[9]={1,2,3,4,5,6,7,8,9};    my_deque<int> tt(a,a+9);    tt.front()+=tt.back();    tt.back()+=tt.front();    my_deque<int>::iterator iter=tt.begin()+2;    tt.insert(iter,a,a+9);    tt.insert(tt.begin(),11);    tt.push_front(12);    tt.push_back(25);    tt.erase(tt.begin()+4);    tt.pop_front();    for(iter=tt.begin();iter!=tt.end();iter++)        cout<<*iter<<endl;    cout<<"size:"<<tt.size()<<endl;    return 0;}

测试结果为：

已基本达到要求，下一章实现序列容器。