stack与queue

1. stack的模拟实现

• 我们这里模拟实现默认用vector来实现

namespace Stack
{
	template <class T, class Container = deque<T>>
	class stack
	{
    public:

        stack()
        {
        }

        void push(const T& x)
        {
            _c.push_back(x);
        }

        void pop()
        {
            _c.pop_back();
        }

        T& top()
        {
            return _c.back();
        }

        const T& top()const
        {
            return _c.back();
        }

        size_t size()const
        {
            return _c.size();
        }

        bool empty()const
        {
            return _c.empty();
        }
    private:
        Container _c;
	};
}

2.queue的模拟实现

namespace Queue
{
    template <class T, class Container = deque<T>>
    class queue
    {
    public:

        queue()
        {}

        void push(const T& x)
        {
            _c.push_back(x);
        }

        void pop()
        {
            _c.erase(_c.begin());
        }

        T& top()
        {
            return _c.front();
        }

        const T& top()const
        {
            return _c.front();
        }

        size_t size()const
        {
            return _c.size();
        }

        bool empty()const
        {
            return _c.empty();
        }
    private:
        Container _c;
    };
}

3. priority_queue的模拟实现

//自己实现的仿函数，仿函数就是一个类模版
template<class T>
class my_less
{
public:
    bool operator()(const T& a, const T& b)
    {
        return a < b;
    }
};
//自己实现的仿函数
template<class T>
class my_greater
{
public:
    bool operator()(const T& a, const T& b)
    {
        return a > b;
    }
};
namespace czy
{
    template <class T, class Container = vector<T>, class Compare = my_less<T> >
    class priority_queue

    {
    public:
        void addjustdown(int parent)
        {
            int child = 2 * parent + 1;
            while (child < c.size())
            {
                if (child + 1 < c.size() && comp(c[child], c[child+1]))
                {
                    child++;
                }
                if (comp(c[parent], c[child]))
                {
                    swap(c[parent], c[child]);
                    parent = child;
                    child = 2 * parent + 1;
                }
                else
                {
                    break;
                }
            }  
        }
        void addjustup(int child)
        {
            int parent = (child - 1) / 2;
            while (child >= 0)
            {
                if (comp(c[parent], c[child]))
                {
                    swap(c[parent], c[child]);
                    child = parent;
                    parent = (child - 1) / 2;
                }
                else
                {
                    break;
                }
            }
        }
        priority_queue()
        {
        }
        template <class InputIterator>
        priority_queue(InputIterator first, InputIterator last)
        {
            while (first!=last)
            {
                push(*first);
                ++first;
            }
        }
        bool empty() const
        {
            return c.empty();
        }
        size_t size() const
        {
            return c.size();
        }
       const T& top() const
        {
            return c.front();
        }
        void push(const T& x)
        {
            c.push_back(x);
            addjustup(c.size()-1);
        }
        void pop()
        {
            swap(c[0], c[c.size() - 1]);
            c.pop_back();
            addjustdown(0);
        }

    private:
        Container c;
        Compare comp;
    };

};

4. 容器适配器

4.1 适配器是什么

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

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

我们在上面模拟实现的是一个用vector为适配器的下面来我们来看一下标准库中的实现

4. 3 deque的介绍

deque成员就是两个迭代器以及一个存放buffer数组地址的数组迭代器里面也有四个指针分别指向每个buffer的开头结束以及当前得位置和当前buffer的地址存放在中控器的那一个位置（通过node指针）。

4.4deque的缺陷

与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。
与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。
但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。

我们了解deque缺点之后我们来看看为什么stack，queue的底层数据结构是deque呢？

• stack，queue不支持迭代器因此就不用便利只需要插入删除刚好避开了deque的缺点
• 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque不仅效率高，而且内存使用率高因为deque里面的buffer是连续的物理空间