C++初阶----deque(双端队列)+stack queue模拟实现

容器适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口
虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque

deque(双端队列)

概念

deque(双端队列)：是一种双开口的"连续"空间的数据结构(和队列没关系)，双开口的含义是：可以头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高

结构

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所示

中控数组map： map数组是一个指针数组，指向多个buff数组用来储存数据，当buff数组头或尾满了，就新开辟一个buff数组，其指针存在map的相对应位置，当map数组满了，会对map数组扩容(指针数组的扩容并不会效率低)，在STL30源码中reallocate_map()函数实现了map数组的扩容
STL30里的stl_deque.h代码如下：

template <class T, class Alloc, size_t BufSize>
void deque<T, Alloc, BufSize>::reallocate_map(size_type nodes_to_add,
                                             bool add_at_front) {
 size_type old_num_nodes = finish.node - start.node + 1;
 size_type new_num_nodes = old_num_nodes + nodes_to_add;

 map_pointer new_nstart;
 if (map_size > 2 * new_num_nodes) {
   new_nstart = map + (map_size - new_num_nodes) / 2 
                    + (add_at_front ? nodes_to_add : 0);
   if (new_nstart < start.node)
     copy(start.node, finish.node + 1, new_nstart);
   else
     copy_backward(start.node, finish.node + 1, new_nstart + old_num_nodes);
 }
 else {
   size_type new_map_size = map_size + max(map_size, nodes_to_add) + 2;

   map_pointer new_map = map_allocator::allocate(new_map_size);
   new_nstart = new_map + (new_map_size - new_num_nodes) / 2
                        + (add_at_front ? nodes_to_add : 0);
   copy(start.node, finish.node + 1, new_nstart);
   map_allocator::deallocate(map, map_size);

   map = new_map;
   map_size = new_map_size;
 }

 start.set_node(new_nstart);
 finish.set_node(new_nstart + old_num_nodes - 1);
}

deque迭代器

deque所谓的连续空间是一个假象，是他底层复杂的迭代器实现
在STL30的源码中deque的迭代器封装了四个指针分别是：

typedef T** map_pointer;
T* cur;
T* first;
T* last;
map_pointer node;

1. cur：是当前node指向的buff数组当前指向的地址
2. first：是当前node指向的buff数组，第一个元素的地址
3. last：是当前node指向的buff数组，最后一个元素的地址
4. node：是指向map数组对应位置的指针，由于它指向的也是一个指针，所以类型为二级指针

STL30源码中也为这个迭代器定义了一个类（参考list迭代器（也是定义一个类）实现）

template <class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator {
}

在deque类中：有两个迭代器类型的变量：

1. start指向第一个buff数组
2. finish指向最后一个buff数组

typedef __deque_iterator<T, T&, T*, BufSiz>             iterator;
typedef __deque_iterator<T, const T&, const T*, BufSiz> const_iterator;
protected:                      // Data members
	iterator start;
	iterator finish;
 public:                         // Basic accessors
	iterator begin() { return start; }
	iterator end() { return finish; }

在我们这样使用的时候：

deque<int> dp;
iterator it=dp.begin();
while(it!=db.end())
{
	*it;         //是*cur
	it++;        //
}
//下面是__deque_iterator类里的成员函数
self& operator++() {
   ++cur;
   if (cur == last) {
     set_node(node + 1);
     cur = first;
   }
   return *this; 
}
bool operator==(const self& x) const { return cur == x.cur; }

当cur==last的时候会重置it的四个指针，指向下一个buff数组

应用（优缺点）

优点：

1. 双端队列，说明他很适合头插头删，尾插尾删，他去做stack和queue的默认适配容器很适合。

缺点：

1. 双端队列中间插入删除数据,非常麻烦。效率不高

1. 方案一： 挪动数据，效率低下（中间插入效率和顺序表一样低，随机访问效率高一些）
2. 方案二： 挪动当前buf数据，记录每个buff数组的大小每个buff数组大小不一致（中间插入效率稍高，随机访问效率低）

2. deque是一种折中方案设计,不够极致。随机访问效率不及vector. 任意位置插入删除不及list

---

stack模拟

参考：stack

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作
2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出
3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：
   empty：判空操作
   back：获取尾部元素操作
   push_back：尾部插入元素操作
   pop_back：尾部删除元素操作
4. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque

template<class T, class Con = std::deque<T>>
   class stack
   {
		//Container 尾认为是栈顶
	public:
		stack()
		{}
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_back();
		}
		const T& top()
		{
			return _con.back();
		}
		size_t size()
		{
			return _con.size();
		}
		bool  empty()
		{
			return _con.empty();
		}
   private:
       Con _con;
   };

queue模拟

注意：vector并不适合做queue的容器类（头部操作效率过低）
参考： queue

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素
2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列
3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:
   empty：检测队列是否为空
   size：返回队列中有效元素的个数
   front：返回队头元素的引用
   back：返回队尾元素的引用
   push_back：在队列尾部入队列
   pop_front：在队列头部出队列
4. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque

template<class T, class Con = std::deque<T>>
   class queue
   {
   public:
		queue()
		{}
		//Container 尾认为是队尾  头认为是队头
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_front();
		}
		const T& front()
		{
			return _con.front();
		}
		const T& back()
		{
			return _con.back();
		}
		size_t size()
		{
			return _con.size();
		}
		bool  empty()
		{
			return _con.empty();
		}
   private:
      Con _con;
   };