C++——容器适配器：stack/queue/priority_queue

stack：栈

概念：

 stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行 元素的插入与提取操作。 先进后出。

 stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类。

这些容器类应该支持以下操作：

• empty：判空操作
• back：获取尾部元素操作
• push_back：尾部插入元素操作
• pop_back：尾部删除元素操作

使用端口：

• stack(const container_type& ctnr = container_type()) 构造空的栈
• bool empty() const 检测stack是否为空
• size_type size() const 返回stack中元素的个数
• value_type& top() 返回栈顶元素的引用
• const value_type& top() const 返回栈顶元素的const引用
• void push (const value_type& val) 将元素val压入stack中
• void pop() 将stack中尾部的元素弹出
• template <class... Args> void emplace (Args&&... args) (C++11) 在stack的栈顶构造元素
• void swap (stack& x)  (C++11) 交换两个栈中的元素

---

使用一：

模拟递归：本例原文

递归模拟演示：阶乘

下面是一个递归函数：

function factorial(n){
    if(n===0){
        return 1
    }else{
        return n*factorial(n-1)
    }
}

使用栈来模拟计算：

function fact(n){
    var s=new Stack();
    while(n>1){
        s.push(n--)
    }
    var product=1;
    while(s.length()>0){
        product*= s.pop();
    }
    return product;
}

思想：自身数字不断的减一入栈，栈中长度大于0就是有数据，出栈相乘。

示例：5为例子；5，4，3，2，1依次入栈；栈中长度大于0；1，2，3，4，5依次出栈相乘。1*1*2*3*4*5 = product

---

使用二：RPN

这里感兴趣的伙伴去看看：RPN

使用三：回溯法

回溯法是五大常用算法之一，回溯法也是一种暴力算法。我们在玩儿迷宫时，其实就用到了回溯法，先选择一条路走，当出现走不通的情况，再返回上一种重新选择一种走法，直到遍历所有节点。常见的八皇后问题也能够使用回溯法来求解。

---

queue：

 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。 

队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。

底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。

该底层容器应至少支持以下操作:

• empty：检测队列是否为空
• size：返回队列中有效元素的个数
• front：返回队头元素的引用
• back：返回队尾元素的引用
• push_back：在队列尾部入队列
• pop_front：在队列头部出队列

端口操作：

• queue (const container_type& ctnr = container_type())    构造空的队列
• bool empty() const 检测队列是否为空，是返回true，否则 返回false
• size_type size() const 返回队列中有效元素的个数
• value_type& front() 返回队头元素的引用
• const value_type& front() const 返回队头元素的const引用
• value_type& back() 返回队尾元素的引用
• const value_type& back() const 返回队尾元素的cosnt引用
• void push(value_type& val) 在队尾将元素val入队列
• void pop() 将队头元素出队列
• template <class... Args> void emplace (Args&&... args) (C++11)    在队尾构造元素
• void swap(queue& x) 交换两个队列中的元素

使用：广度优先遍历（二叉树的层序遍历）

---

priority_queue：堆

 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。 2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特 定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。

容器应该可以通过随机访问迭代器访问，并支持以下操作：

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

函数声明：

• priority_queue(const Compare& x = Compare(),  const Container& y = Container() );    构造一个空的优先 级队列
• template     priority_queue(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Container& ctnr = Container());    用[first, last)区间 中的元素构造优先 级队列
• bool empty( ) const     检测优先级队列是 否为空，是返回 true，否则返回 false
• const value_type& top ( ) const    返回优先级队列中 最大(最小元素)， 即堆顶元素
• void push ( const T& x )    在优先级队列中插 入元素x
• void pop ( )   删除优先级队列中 最大(最小)元素， 即堆顶元素

使用：TOP K问题

---

为什么将stack、queue和priority_queue称作为容器适配器？

虽然stack、queue、priority_queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为每个容器在底层都有自己的实现方式，而stack、queue、priority_queue只是在底层将其他容器进行了封装。

为什么选择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不仅效率高，而且内存使用率高。