stl_stack/queue

一.适配器

stack和queue实际上并不能算是一种容器，而是一种容器适配器。而适配器作为stl的6大组件之一，其实是一种设计模式。适配器模式其实就是将一个类的接口（该接口无法直接满足客户的需求）转换成客户希望的另一个接口，以满足客户的需求。

而对于stack和queue来说，其就是借助另一个容器实现了LIFO(last in firtst out)和FIFO(first in first out)的功能。

而我们看到stack和queue的第二个模板参数容器给了缺省值，如果不指定容器，就会默认用deque来实现queue和stack。当然也可以利用其他的容器来实现，但是容器的结构一定得符合queue和stack的压入和弹出规则。

二.模拟实现stack

模拟实现stack时，必须要遵循stack的规则LIFO(last in first out)。而栈的接口只有压栈、出栈、取栈顶元素等操作，而我们用vector就可以完美实现stack的接口。

压栈直接调用vector的push_back即可，出栈调用vector的pop_back，取栈顶元素调用vector的back。

namespace xsc
{template<typename T,typename Container = vector<T>>class stack{public:void push(const T& val){_con.push_back(val);}void pop(){_con.pop_back();}T& top(){return _con.back();}bool empty(){return _con.empty();}int size(){return _con.size();}private:Container _con;};
}

但是当我们了解了list的结构之后，发现其也可以很好的实现stack的各种接口。所以我们使用栈时，既可以用缺省参数vector，也可以显式给出容器list。

xsc::stack<int> is;
xsc::stack<double, list<double>> is2;

三.模拟实现queue

模拟实现queue时，我们要了解其规则FIFO(first in first out).当我们要借助其他容器来实现queue时就不能再用vector来实现了。因为queue涉及到了删除队头的数据，vector并没有头删的接口，当然list和vector都有erase的接口，我们可以借助这个来实现，但是用vector会涉及到数据的挪动影响效率。所以我们默认采取list来实现queue。

queue的push借助list的push_back，pop借助list的pop_front，back、front分别借助list的back和front

namespace xsc
{template<typename T,typename Container = list<T>>class queue{public:void push(const T& val){_con.push_back(val);}void pop(){_con.pop_front();}T& front(){return _con.front();}T& back(){return _con.back();}bool empty(){return _con.empty();}int size(){return _con.size();}private:Container _con;};
}

四.deque

虽然我们借助list或者vector实现了stack和deque，但是我们看到标准库中栈和队列的容器参数默认是deque。那什么是deque呢？

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

我们可以看一下deque都实现了那些接口：

deque其实是vector和list的结合体。

因为vector和list都有其各自的优点和一些不足，所以设计容器的人就想是否可以设计出一个容器既包含vector的优点也包含list的优点——所有deque就问世了。

但是deque并没有达到预期，如果deque真的实现了vector和list优点的结合，那么vector和list就不会再用人用了。

1.vector和list的对比

vector的优点：

1、尾插尾删效率不错，支持高效下标随机访问

2、物理空间连续，所以高速缓存利用率高

vector的缺点：

1、空间需要扩容，扩容有一些代价(效率和空间浪费)，且这个代价到后期数据多的时候更大

2、头部和中间插入/删除效率低(挪动数据)

list的优点：

1、按需申请释放空间，不需要扩容

2、支持任意位置O(1)的插入删除

list的缺点：

1、不支持下标的随机访问

2.deque的结构

deque的底层结构并不是一段连续的物理空间，而是类似于一个二维数组。由一个中控数组和若干个buff组成。

中控数组map其实是一个指针数组，其中存储着指向一个个buffer的指针。而buffer是一个定长数组(或者动态数组)，所有的数据都存储在buffer上。

不同的是，中控数组map是从中间开始存储的，第一个buffer的指针存储在中控数组的中间部分，如果要头插就在该位置的前面存储一个buffer的地址。当map满了之后还需要对map进行扩容。

deque还重载了[] ，那么deque是如何支持下标访问的呢？

我们可以采取/和%的方式，定位到指定下标的元素位置。

假设要获取下标为i的元素，每一个buffer的大小为N。我们先用 x = i / N就可以得到该元素位于第几个buffer中；然后用y = i % N就可以知道该元素是这个buffer的第几个位置，然后借助两次operator[][]的调用map[x][y]就可以得到该数据。

3.deque的迭代器

deque的迭代器是由4个指针来实现的

cur指向当前正在访问的元素，first指向这段buffer的开始位置，last指向这段buffer的结束位置，node指向中控数组中存储这个buffer的位置。

借助这个迭代器，deque模拟出来物理空间连续的假象。

当我们遍历时，当cur等于last时说明这个buffer已经遍历完了，此时需要走到下一个buffer，只需要让node++即可。

4.deque的维护

deque这个容器的维护主要是借助两个迭代器来实现的：

这两个迭代器就相当于begin()和end()。分别指向开始和结尾。

遍历容器时，其实是创建一个迭代器，然后将start的值给他，然后通过cur来遍历。

5.deque的push_back()/push_front()

deque的尾插和头插效率都很高，尾插直接向buffer里面插入即可，如果buffer满了在申请一个即可。

deque的头插数据的方式有些许不同。头插时是往中控数组的的前面插入一个buffer，然后将头插的元素插入到buffer的尾部。

要注意的是头插和尾插之后start和finish都需要改变。

6.deque的insert/erase

当在中间位置插入删除时，有两种方式：

1、挪动数据，保证buffer的大小不变，但是这样就会导致效率极低

2、扩大或缩小buffer，但是这样会导致下标访问会更加困难，不能用/和%的方式得出下标位置。

总结：

1、deque的头尾插入删除效率很高，更甚于vector和list

2、下标随机访问也还不错，但略逊于vector

3、中间位置的插入删除效率很低O(N)，需要挪动数据

7.deque的缺陷

与vector比较，deque的优势是：头部插入和删除时，不需要挪动数据，效率特别高，而且在扩容时，也不需要搬移大量数据，因此其效率是比vector高的。

与list比较，其底层空间是连续空间，空间利用率比较高，不需要存储额外字段

但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器需要频繁的去检查其是否移动到buffer的边界，导致效率低下，而在序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构

8.为什么选择deque作为stack和queue的底层默认容器

stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性结构，都可以作为stack的底层容器，比如vector和list；

queue是先进先出的特殊线性数据结构，只要具有push_back()和pop_front()操作的线性结构，都可以作为queue的底层容器，比如：list。

但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

1、stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作

2、在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque不仅效率高，而且内存使用率还高。

结合了deque的优点，而完美的避开了其缺陷。

9.对比deque和vector的排序效率

我们从结果可以分析出，在存储相同数据的情况下，不论是直接比较deque和vector，还是用两个存储相同数据的deque，一个直接排序，一个先将数据拷贝到vector中，排序，拷贝会去，效率都是采用vector的高。

这是因为在sort算法下采用的是快排，快排需要对数据进行访问，而vector对数据的随机访问效率要比deque高得多。

void test_op1()
{srand(time(0));const int N = 1000000;deque<int> dq;vector<int> v;for (int i = 0; i < N; ++i){auto e = rand() + i;v.push_back(e);dq.push_back(e);}int begin1 = clock();sort(v.begin(), v.end());int end1 = clock();int begin2 = clock();sort(dq.begin(), dq.end());int end2 = clock();printf("vector:%d\n", end1 - begin1);printf("deque:%d\n", end2 - begin2);
}void test_op2()
{srand(time(0));const int N = 1000000;deque<int> dq1;deque<int> dq2;for (int i = 0; i < N; ++i){auto e = rand() + i;dq1.push_back(e);dq2.push_back(e);}int begin1 = clock();sort(dq1.begin(), dq1.end());int end1 = clock();int begin2 = clock();// 拷贝到vectorvector<int> v(dq2.begin(), dq2.end());sort(v.begin(), v.end());dq2.assign(v.begin(), v.end());int end2 = clock();printf("deque sort:%d\n", end1 - begin1);printf("deque copy vector sort, copy back deque:%d\n", end2 - begin2);
}

五.priority_queue

1.priority_queue基本概念

priority_queue就是优先级队列，它也是一种容器适配器。但是它不同于queue，不再以deque作为底层容器，而是vector。

而priority_queue在底层是vector的前提下，又采用了堆的算法，将其包装成一个堆。所以priority_queue其实就是一个堆(默认是大堆)。其设计的一系列接口也都是模拟了堆的行为。

top取出堆顶的元素(最大/最小的元素)

push插入数据然后采用向上调整算法使其依旧是一个堆

pop删除堆顶的数据然后采用向下调整算法使其依旧是一个堆

在使用向上(向下)调整算法时，要保证其原本就是堆。

小伙饿坏了，赶紧点了一份爱学的二叉树——堆，狼吞虎咽学完很过瘾-CSDN博客

在这里可以回顾一下堆的基本操作：

1、堆是一个完全二叉树，完全二叉树就是前面每层都是满的，最后一层从左到右是连续的。

2、知道一个父亲节点的下标parent，怎么求它的左右孩子：left = 2*parent+1,right = 2*parent+2

3、知道孩子节点的下标child，怎么求父亲节点：parent = (child-1)/2.

4、大堆：父亲节点的值大于等于左右孩子的值，但左右孩子之间没有大小关系

5、小堆：父亲节点的值小于等于左右孩子的值，但左右孩子之前没有大小关系。

6.插入节点：插入节点是插入到最后一层从左到右的最后一个位置，但是插入必须要保证插入之后也是一个堆，所以插入之后要进行向上调整，与它的父亲节点比较，如果是大堆的话，插入的大于父亲节点就交换，直到小于某个父亲节点或者到达堆顶就停止交换。

7.删除堆顶元素：首先将堆顶元素与最后一个节点交换，然后再删除最后一个节点，然后进行向下调整，使之仍然是堆

优先级队列之所以默认是大堆，原因在于其第三个模板参数，当我们改变第三个模板参数时，就可以将其变为小堆

//priority_queue<int> q; // 大堆
priority_queue<int,vector<int>,greater<int>> q; // 小堆

2.模拟实现priority_queue

默认是大堆

插入之后向上调整时，将孩子与父亲进行比较，如果孩子大于父亲就交换，直到孩子小于父亲/已经交换到了堆顶。

删除之后向下调整时，父亲与左右孩子大的那个交换（采取假设法：先假设左孩子大，再判断右孩子是否大于左孩子，如果大于那么child+1），直到父亲大于左右孩子，或者已经交换到最后一层。

小伙饿坏了，赶紧点了一份爱学的二叉树——堆，狼吞虎咽学完很过瘾-CSDN博客

namespace xsc
{//默认是大堆template <typename T, typename Container = vector<T>>class priority_queue{public:void AdjustUp(int child){int parent = (child - 1) / 2;while (child > 0){if (_con[child] > _con[parent]){swap(_con[child], _con[parent]);child = parent;parent = (child - 1) / 2;}else{break;}}}void push(const T& val){_con.push_back(val);AdjustUp(_con.size() - 1);}void AdjustDown(int parent){int child = parent * 2 + 1;while (child < _con.size()){if (child + 1 < _con.size() && _con[child] < _con[child + 1])//只有这个条件可能会越界：a[child] > a[child + 1]{child += 1;}if (_con[parent] < _con[child]){swap(_con[child], _con[parent]);parent = child;child = parent * 2 + 1;}else{break;}}}void pop(){swap(_con[0], _con[_con.size() - 1]);_con.pop_back();AdjustDown(0);}T& top(){return _con[0];}bool empty(){return _con.empty();}int size(){return _con.size();}private:Container _con;};
}

那如果要实现一个小堆呢？难道要写出两个类模板么？

在标准库中的priority_queue是借助第三个模板参数来实现的：

//priority_queue<int> q; // 大堆
//priority_queue<int, vector<int>, less<int>>;// 第三个默认参数是less<int>priority_queue<int,vector<int>,greater<int>> q; // 小堆

而这第三个模板参数其实是借助仿函数来实现的。

3.仿函数

仿函数人如其名，它并不是一个函数，而是一个重载了()的一个类或者结构体，它可以使其看上去像一个函数一样，像函数一样使用。仿函数可以接受参数并返回值，可以用于STL算法中的函数对象参数，也可以用于函数指针的替代。

template <typename T>
struct Less
{bool operator()(const T& x, const T& y){return x < y;}
};int main()
{Less<int> l;cout << l(1, 2) << endl;return 0;
}

我们实际上是借助这个类创建了一个对象，但是我们使用这个对象的方式却是调用函数的行为，这就是仿函数。

实际上是调用了该类的operator()。

cout << l.operator(1, 2) << endl;

我们可以实现两个仿函数Less和Greater来封装比较的逻辑，对priority_queue增加第三个模板参数，并将其内部的比较都换成仿函数的比较方式，以此来改变向上向下调整的比较逻辑，实现大堆/小堆。

在库中，less默认是<，gerater默认是>，所以我们采取和库里一样的比较方式。

template <typename T>
struct Less
{bool operator()(const T& x, const T& y){return x < y;}
};template <typename T>
struct Greater
{bool operator()(const T& x, const T& y){return x > y;}
};