Chapter 4: 序列式容器之 stack 和 queue

一：stack

1：stack 概述

$\quad$stack 是一种先进后出的数据结构，它只有一个出口。stack 允许新增元素，移除元素，取得最顶端元素，但除了最顶端外，没有任何其它方法可以存取 stack 的其它元素，换言之，stack 不允许有遍历行为，因此 stack 没有迭代器；

$\quad$将元素推入 stack 的操作称为 push，将元素推出 stack 的操作称为 pop。

2：stack 定义完整列表

1)：stack 默认是以 deque 作为其底部实现结构的。由于 stack 系以底部容器完成其所有工作，而具有某种“修改某物接口，形成另一种风貌”之性质，所以称为配接器(adapter)。因此 STL stack 往往不被归类为 container（容器），而被归类为 container adapter；

2)：stack 的完整实现代码：

template <class T, class Sequence = deque<T>>
class stack {
        friend bool operator==(const stack&, const stack&);
        friend bool operator<(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;     //底层容器

public:
        //以下完全利用 Sequence c 的操作，完成 stack 的操作
        bool empty() const { return c.empty(); }
        size_type size() const { return c.size(); }
        reference pop() { return c.back(); }
        const_reference pop() const { return c.back(); }

        //deque 是两头可进出，stack 是末端进，末端出（所以后进者先出）
        void push(const value_type& x) { c.push_back(x); }
        void pop(const value_type& x) { c.pop_back(x); }
};

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

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

二：queue

1：queue 概述

$\quad$queue 是一种先进先出的数据结构，它有两个出口，queue 允许新增元素，移除元素，从最底端加入元素和取得最顶端元素。但除了最底端可以加入，最顶端可以取出外，没有任何其它方法可以存取 queue 的其它元素，换言之，queue 不允许有遍历行为，因此 queue 没有迭代器；

$\quad$将元素推入 queue 的操作称为 push，将元素推出 queue 的操作称为 pop。

2：queue 定义完整列表

1)：和 stack 一样，queue 也默认是以 deque 作为其底部实现结构的，并且也和 stack 一样，也是 container adapter（容器配接器）；

2)：queue 的完整代码如下：

template <class T, class Sequence = deque<T>>
class queue {
        friend bool operator==(const queue&, const queue&);
        friend bool operator<(const queue&, const queue&);

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:
        //以下完全利用 Sequence c 的操作，完成 queue 的操作
        bool empty() const { return c.empty(); }
        size_type size() const { return c.size(); }
        reference pop() { return c.back(); }
        const_reference pop() const { return c.back(); }

        //deque 是两头可进出，queue 是底端进，顶端出（所以先进者先出）
        void push(const value_type& x) { c.push_back(x); }
        void pop(const value_type& x) { c.pop_front(x); }
};

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

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