【C++】stack和queue

一、stack

stack就类似于我们数据结构所学的栈 

 stack是一种容器适配器 

什么是适配器 

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

举个例子：某插头要求输入：100-240V~，50/60Hz，0.7A

输出：5V==3A/9V==3A/12V= 2.25A 20V=1.35A/11V=3A Max

这就是适配器

之后我们看到上图stack的模板，Container = deque<T>默认容器是deque<T>

template<class T, class Container = deque<T>>

在这里先说明一下deque<T>这种容器不是数据结构中的栈专门给stack设计一个类似于栈的容器

而是利用deque这个容器的功能，转换成可以实现stack后进先出的容器。这种就可以理解为适配器

1.1 deque 

 什么是deque？

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作。 

 deque是空间配置器和vector以及list一样都是空间配置器

vector和list我们了解过，vector顺序表，list链表

那deque又是以什么样的方式存储？deque其实相当于vector的功能＋list的功能

deque的底层是： 

map指向的是指针数组，start与finish是deque的迭代器

start是指向第一个buff，迭代器中的first指向buff的第一个位置，last指向buff最后的一个位置，cur指向buff第一个存储的数据，node指向的是map中的某个buff

deque遍历无非就是解引用cur，然后移动cur的位置，再通过node找到下一个buff。 

deque在这个图的基础上，头插，无非就是新开一个buff，这里的1,2插入buff的后面，迭代器start发生改变。如下图

尾插push_back(6);push_back(7);6则是插在buff16 17 18 19 0 1 2，2的后面，7则是开辟一个新buff，插在buff的前面，迭代器finish发生改变

具体的代码细节可以看STL

 了解deque这个空间配置器后，为什么stack不用vector与list当空间配置器

 vector优势：下标访问效率高

           劣势：扩容，头部插入删除效率低

 list优势：按需申请释放，任意位置插入删除效率都不错

      劣势：下标访问效率低

与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率必定是vector高的。

与list比较，其底层是连续空间方便高速访问，空间利用率比较高，不需要存储额外字段。

总的来说deque融合了vector与list的优势与劣势  

deque的结构：不适合遍历，不如vector。中间位置insert和erase也需要考虑挪动数据，效率不高，不如list。但是stack是后进先出，不用中间插入，也不需要遍历

deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。 

1.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;
    };

当然不使用模板中的缺省参数deque<T>也行 ,使用list和vector这种容器也可以，想怎么来就怎么来

stack<int,list<int>> s

二、<queue>

 queue中有两个类先介绍queue

2.1 queue 

queue类似于数据结构的队列

queue使用的容器依旧是deque，了解上面的deque直接模拟实现一下

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

2.2、priority_queue

priority_queue是一个适配器，其实就是数据结构的堆 

我们不难发现在类模板里出现了，class Compare = less<>这个就是访函数

这里我们简单介绍一下 仿函数/函数对象：重载了operator()类，类的对象可以像函数一样使用。

什么意思呢？

    class Func
    {
    public:
        void operator()()
        {
            cout << "Func调用" << endl;
        }
    };

在main函数中，我们通过类建立一个对象f1，f1()其实就是f1.operator()() 

        Func f1;
        f1();

 下面模拟一个priority_queue这个适配器 

实现小堆的类 

    template<class T>
    class mygreater
    {
    public:
        bool operator()(const T& x, const T& y)
        {
            return x > y;
        }
    };

实现大堆的类 

    template<class T>
    class myless
    {
    public:
        bool operator()(const T& x, const T& y)
        {
            return x < y;
        }
    };

上面两个仿函数具体的功能，下面部分有具体介绍。

    template<class T, class Container = vector<T>, class Compare = myless<T>>
    class priority_queue
    {
    public:   
    private:
        Container _con;
    };

因为编译器默认生成大堆这种结构，所以这里我们也默认生成大堆。这里使用的缺省参数是仿函数myless<T>

下面是priority_queue的功能 

这里模拟实现C++98的功能

 先实现push功能

        void AdjustUp(int child)
        {
            Compare comfunc;
            int parent = (child - 1) / 2;
            while (child > 0)
            {
                //if (_con[parent] < _con[child])
                if(comfunc(_con[parent] ,_con[child]))
                {
                    swap(_con[parent], _con[child]);
                    child = parent;
                    parent = (child - 1) / 2;
                }
                else {
                    break;
                }
            }
        }
        void push(const T& x)
        {
            _con.push_back(x);
            AdjustUp(_con.size() - 1);
        }

不难理解，先用vector尾插数据，之后要实现大堆的结构---因为之前详细介绍过这里就不细细讲解

http://t.csdnimg.cn/JSvmm 这篇文章有介绍

我们重点看一下向上调整法中的Compare comfunc;

我们不难发现，如果使用的是myless，因为父节点<子节点，父子交换，大数向前移

如果使用的是mygreater，正好发生了转换，父节点>子节点，父子交换，小数向前移

我们通过仿函数，不需要频繁的向函数中修改大于小于，而是直接调用。

实现pop功能 

        void AdjustDown(int parent)
        {
            Compare comfunc;
            int child = parent * 2 + 1;
            while (child < _con.size())
            {
                //if (child + 1 < _con.size() && _con[child] < _con[child + 1])
                if (child + 1 < _con.size() && comfunc(_con[child], _con[child + 1]))
                {
                    ++child;
                }
                if (comfunc(_con[parent], _con[child]))
                {
                    swap(_con[parent], _con[child]);
                    parent = child;
                    child = parent * 2 + 1;
                }
                else {
                    break;
                }
            }
        }

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

这里实现的是向下调整法其中Compare comfunc;和push中的Compare comfunc无太大差别的意思

 下面是top以及size，empty的功能，直接使用vector中的功能

        const T& top()
        {
            return _con[0];
        }
        size_t size()
        {
            return _con.size();
        }
        bool empty()
        {
            return _con.empty();
        }

最后就是构造

        template<class InputIterator>
        priority_queue(InputIterator first, InputIterator last)
        {
            while (first != last)
            {
                //这里可以使用本类中push但是向上调整算法时间复杂度为O(N*logN);最好直接建堆，直接建堆的复杂度是O(N)
                _con.push_back(*first);
                ++first;
            }
            // 建堆
            for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
            {
                AdjustDown(i);
            }
        }