STL浅析 stack、queue

stack

stack是一种先进后出的数据结构，它只有一个出口，只能够在顶端新增、移除、取得元素，没有其他方式进行操作。stack不支持随机访问。

stack的基础容器

stack默认是以deque作为基础容器来实现的。
使用vector作为基础容器在拓展容量时需要[开辟新内存，复制元素，释放就内存]有较高的时间复杂度，不适合stack。而deque的扩容动作比vector小的多，只需要[开辟新内存]就足够了。
使用list作为基础容器时，每一次增加和删除一个元素时都需要新建或删除一个节点，需要开辟空间并指定节点的前节点和后节点，而deque是一次性开辟一块连续内存。虽然list更稳定，但从平均时间复杂度来讲，deque更优。

综上，stack使用deque更好。

stack定义

由于stack是在底部容器的基础上完成所有工作，所以不被称为容器，而被归类为 container adapter（容器适配器）。
正因以deque作为基础容器，所以stack的代码非常简短，以下为stack定义：

template <class T, class Sequence = deque<T> >
class stack {
  friend bool operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&);
  friend bool operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&);
public:
    typedef typename Sequence::value_type value_type;
    typedef typename Sequence::size_type size_type;
    typedef typename Sequence::reference reference;
    typedef typename Sequence::const_reference const_reference;
protected:
    Sequence c;           // 底层容器，默认为deque
public:
    //Sequence接口的封装
    bool empty() const { return c.empty(); }
    size_type size() const { return c.size(); }
    reference top() { return c.back(); }
    const_reference top() const { return c.back(); }
    void push(const value_type& x) { c.push_back(x); }
    void pop() { c.pop_back(); }
};

template <class T, class Sequence>
bool operator==(const stack<T, Sequence>& x, const stack<T, Sequence>& y) {
	return x.c == y.c;
}

template <class T, class Sequence>
bool operator<(const stack<T, Sequence>& x, const stack<T, Sequence>& y) {
	return x.c < y.c;
}

stack没有迭代器

stack 所有元素的进出都必须符合「先进后出」的条件，只有 stack 顶端的元素，才有机会被外界取用。stack 不提供随机访问，也不提供迭代器。

queue

queue是一种先进先出的数据结构，它允许在队尾追加元素和访问队尾元素， 在队头获取和移除元素，除此之外其不支持其它元素的访问。和stack一样，它不需要迭代器，并且也是一种container adapter，默认以deque为底层容器。

queue定义

template <class T, class Sequence = deque<T> >
class queue
{
  friend bool operator== __STL_NULL_TMPL_ARGS (const queue& x, const queue& y);
  friend bool operator< __STL_NULL_TMPL_ARGS (const queue& x, const queue& y);
 
public:
  typedef typename Sequence::value_type value_type;
  typedef typename Sequence::size_type size_type;
  typedef typename Sequence::reference reference;
  typedef typename Sequence::const_reference const_reference;
 
protected:
  Sequence c;
 
public:
 
  bool empty() const { return c.empty(); }
  size_type size() const { return c.size(); }
  reference front() { return c.front(); }
  const_reference front() const { return c.front(); }
  reference back() { return c.back(); }
  const_reference back() const { return c.back(); }
  void push(const value_type& x) { c.push_back(x); }
  void pop() { c.pop_front(); }
};
 
template <class T, class Sequence>
bool operator==(const queue<T, Sequence>& x, const queue<T, Sequence>& y)
{
  return x.c == y.c;
}
 
template <class T, class Sequence>
bool operator<(const queue<T, Sequence>& x, const queue<T, Sequence>& y)
{
  return x.c < y.c;
}