【STL】stack & queue & priority_queue {栈，队列，优先级队列的介绍及使用；仿函数/函数对象；容器适配器，双端队列deque}

一、stack

1.1 stack的介绍

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

1.2 stack的使用

---

二、queue

2.1 queue的介绍

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

2.2 queue的使用

---

三、priority_queue

3.1 priority_queue的介绍

1. 优先队列是一种容器适配器，根据严格的弱排序标准（默认调less），它的第一个元素总是它所包含的元素中最大的（默认是大堆）。

2. 优先级队列实际上就是我们之前学过的数据结构——堆，在堆中可以随时插入元素，并且只能检索最大/小堆元素(优先队列中位于顶部的元素)。

3. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

   • empty()：检测容器是否为空
   • size()：返回容器中有效元素个数
   • front()：返回容器中第一个元素的引用
   • push_back()：在容器尾部插入元素
   • pop_back()：删除容器尾部元素

4. priority_queue不支持迭代器，不支持随机访问。

5. 标准容器类vector和deque满足这些需求。如果没有为priority_queue指定特定的底层容器，默认情况下使用vector。

6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

3.2 priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。

注意：默认情况下priority_queue是大堆。

3.3 仿函数

如何将priority_queue调整为小堆？
很简单，我们只需要传入第三个模版参数Compare即可。

• Compare是一个仿函数。仿函数又叫函数对象，实际上是一个类/类模版，其中重载了operator()。
• 用这样的类实例化出来的对象可以像函数一样使用。

//<functional>库中的less和greater类模版（仿函数），其行为等价于下面的代码：
template <class T>
struct Less
{
	bool operator()(const T &l, const T &r) const{
		return l < r;
	}
};

template <class T>
struct Greater
{
	bool operator()(const T &l, const T &r) const{
		return l > r;
	}
};
//将priority_queue调整为小堆：
void Test1(){
	Less<int> ls;
	Greater<int> gt;
	cout << ls(1,2) << " "; //实例化出来的对象可以向函数一样去使用
	//等价于：
	//cout << ls.operator()(1,2) << " ";
	cout << gt(1,2) << endl;
}

void Test2(){
	int arr[] = {1,3,2,4,5};
	priority_queue<int> heap1(arr, arr+5); //缺省第三个模版参数，默认传less是大堆。
	priority_queue<int, vector<int>, greater<int>> heap2(arr, arr+5); //传greater，是小堆
	//输出逐个heap1,heap2的堆顶元素
	//......
}

输出：
Test1：1 0
Test2：heap1：5,4,3,2,1；heap2：1,2,3,4,5;

porority_queue的第三个模版参数：

• 传less<T>，建大堆（默认情况）；
• 传greater<T>，建小堆；

我们回顾一下sort的用法：

• sort的第三个参数可以传一个仿函数，用于控制升降序。
• sort是一个函数模版，需要通过传入的参数推演其模版参数。因此，这里的comp传入的不是类型而是示例化出的对象（一般采用匿名对象）。传less<T>() 排升序（默认情况）；传greater<T>() 排降序。
• 在C语言中，我们通过传入函数指针完成类似的工作：比如qsort函数，需要传入函数指针，指向用于比较元素的函数。
• 同样，这里sort的第三个参数也可以传入一个函数指针进行比较。
• 但priority_queue的模版参数不能传函数指针类型，因为用于比较大小的less和greater函数类型相同，不能通过类型进行区分。

---

四、容器适配器

4.1 什么是适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

4.2 STL标准库中stack和queue的底层结构

虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了封装，STL中stack和queue默认使用deque：

适配器模式的优势：

1. 免去了重复的代码，增强了代码的复用性；
2. 同一个适配器可以采用多种底层结构以适应实际的应用需求；

int main()
{
    //同一个适配器可以采用多种底层结构以适应实际的应用需求：
    stack<int, deque<int>> st1; //底层结构是一个双端队列
    stack<int, vector<int>> st2; //底层结构是一个顺序表
    stack<int, vactor<int>> st3; //底层结构是一个链表
    return 0;
}

4.3 deque的简单介绍(了解)

4.3.1 deque的原理介绍

deque(double ended queue——双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要挪动元素；与list比较，空间利用率比较高，访存速度更快。

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

提示：

1. 中控器map实际上是一个指针数组
2. 中控器中的第一个buffer（存放第一个插入的数据）的指针不是从头开始存放的，而是从中间开始。这样设计是为了方便头插和尾插时向前向后双向扩容。
3. 尾插时，buffer中的数据时从前往后插入的，当前buffer满载后在中控器的下一个位置再申请一块buffer；而头插时，buffer中的数据是从后往前插入的，当前buffer满载后在中控器的前一个位置再申请一块buffer；
   4.当中控器map满载后，便需要再申请一块更大的空间作为map，当然也要拷贝原map中的buffer指针，不过相比vector，deque的扩容代价很小。

deque重载了operator[]，支持随机访问：

• 假设要访问其下标为i的元素。设第一块缓冲区（存放第一个数据的缓冲区，下标为0）的大小为b1_size，每块缓冲区的容量为8。
• 在头插向前扩容的情况下，第一块缓冲区可能不满（并不是从第一个位置存储数据的），因此要先减去第一缓冲区的大小：i -= b1_size。
• 如果i<0，说明该元素就在第一块缓冲区，该元素在缓冲区中的下标：i+8。[0, i+8]
• 如果i>=0，首先计算该元素在那一块缓冲区：i/8+1，然后计算该元素在该缓冲区中的下标：i%8。[i/8+1, i%8]
• 通过上述的计算，我们就能的到数据在deque中的二维坐标，第一维确定中控器中相对第一缓冲区的偏移量，第二维确定buffer中的位置，由此来实现deque的随机访问。

双端队列底层是一段假想的连续空间，实际是分段连续的，为了维护其“整体连续”的假象，连续遍历的任务就落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：

那deque是如何借助其迭代器维护其假想连续的结构呢？

如上图所示，start.first指向第一块buffer的第一个元素；finish.last指向最后一块buffer的最后一个元素之后；当it.cur遍历到第一块buffer的last位置时，++node定位到下一块buffer，更新迭代器的first和last，再让cur = first开始遍历第二块buffer。如此步骤执行直到it.cur == finish.last，即遍历结束。

4.3.2 deque的优势和缺陷

优势：

与vector比较：

• 头部插入和删除时，不需要搬移元素，效率特别高。

• 在扩容时，不需要拷贝大量的元素，因此其效率是比vector高的。

与list比较：

• 其底层是相对连续的空间，空间利用率比较高，且不需要存储额外字段。

• 重载了operator[]，支持随机访问。

• CPU高速缓存的命中率更高，访存速度更快。

缺陷：

1. operator[]计算稍显复杂，大量频繁的进行随机访问，性能下降。

2. 中间插入删除也需要挪动数据，效率不高。

3. deque的迭代器底层设计相对复杂，且相比vector迭代器遍历效率较低。

提示：在遍历时，deque的迭代器要频繁的去检测其是否移动到某段buffer的边界，导致效率低下。

总结：

1. 相比vector和list而言，头尾的插入和删除更加高效，空间利用率更高。因此很适合去做stack和queue的默认适配容器。
2. 中间的插入和删除多用list
3. 随机访问多用vector

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

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

1. stack和queue不需要遍历和随机访问（因此stack和queue没有迭代器和operator[]）。
2. 栈和队列的性质：只需要在固定的一端或者两端进行操作，不需要进行中间的插入和删除。
3. 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque比list访存速度更快，而且空间利用率高。
4. 结合了deque的优点，而完美的避开了其缺陷，deque是stack&queue底层容器的最佳选择。