容器适配器&&stack，queue，priority_queue的模拟实现

1.容器适配器

容器适配器就是封装某些容器，使其满足一些特定场景下的需求,STL提供了三种容器适配器，分别是stack,queue,priority_queue。前两者的底层容器为deque,而priority_queue的底层容器为vector.

2.stack的模拟实现

template<class T, class Con = deque<T>>
class stack
{
public:
    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:
    Con _c;
};

3.queue的模拟实现

template<class T, class Con = deque<T>>
class queue
{
public:
    void push(const T& x)
    {
        _c.push_back(x);
    }

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

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

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

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

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

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

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

4.priority_queue的模拟实现

template <class T, class Container = vector<T>,class Compare = greater<T>  >
class priority_queue
{
public:
    priority_queue()
    {

    }
    void adjustup(int child)
    {
        int parent = (child - 1) / 2;
        while (child)
        {
            if (comp(c[parent], c[child]))
            {
                swap(c[parent], c[child]);
                child = parent;
                parent = (child - 1) / 2;
            }
            else break;
        }
    }

    template <class inputiterator>
    priority_queue(inputiterator first, inputiterator last)
    {
        vector<T>v(first, last);
        swap(c, v);
        for (int i = (c.size()-1-1)/2; i >= 0; i--) adjustdown(i);
    }

    bool empty() const
    {
        return c.empty();
    }

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

    T& top()
    {
        return c[0];
    }

    const T& top()const
    {
        return c[0];
    }
    void push(const T& x)
    {
        c.push_back(x);
        adjustup(c.size()-1);
    }

    void adjustdown(int parent)
    {
        int child = parent * 2 + 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]);
            else break;
            parent = child;
            child= parent * 2 + 1;
        }
    }

    void pop()
    {
        swap(c[0], c[c.size() - 1]);
        c.pop_back();
        adjustdown(0);
    }

private:
    Container c;
    Compare comp;
};