C++ STL stack & queue

简介: stack是一种容器适配器,专门用在具有后进先出操作的上下文环境中,其删除只能从容器的一端进行元素的插入与提取操作。

 

目录

一.stack 介绍

二.stack 使用

三.stack 模拟实现

普通版本:

适配器版本:

四.queue的介绍

五. queue使用

六.queue模拟实现

七.deque介绍

1.容器适配器

2.deque的简单介绍

3.deque的缺陷

4.为什么选择deque作为stack和queue的底层默认容器


一.stack 介绍

stack------reference

1. stack是一种容器适配器,专门用在具有后进先出操作的上下文环境中,其删除只能从容器的一端进行元素的插入与提取操作。

2. stack是作为容器适配器被实现的,容器适配器即是对特定类封装作为其底层的容器,并提供一组特定的成员函数来访问其元素,将特定类作为其底层的,元素特定容器的尾部(即栈顶)被压入和弹出。

3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类,这些容器类应该支持以下操作:

    • empty:判空操作
    • back:获取尾部元素操作
    • push_back:尾部插入元素操作
    • pop_back:尾部删除元素操作

    4. 标准容器vector、deque、list均符合这些需求,默认情况下,如果没有为stack指定特定的底层容器,默认情况下使用deque。

    image.gif编辑

    二.stack 使用

    函数说明 接口说明
    stack() 构造空的栈
    empty() 检测stack是否为空
    size() 返回stack中元素的个数
    top() 返回栈顶元素的引用
    push() 将元素val压入stack中
    pop() 将stack中尾部的元素弹出

    三.stack 模拟实现

    普通版本:

    stack的模拟实现非常简单,我们利用已经学过的vector去封装他的几个接口就可以了。

    template<class T>
      class Stack
      {
      public:
        Stack()
        {}
        const T& top()
        {
          return _v.back();
        }
        void pop()
        {
          return _v.pop_back();
        }
        void push(const T& val)
        {
          _v.push_back(val);
        }
        size_t size()
        {
          return _v.size();
        }
        bool empty()
        {
          return _v.empty();
        }
      private:
        vector<T> _v;
      };
        int main()
        {
          Stack<int> st;
          st.push(100);
          st.push(200);
          st.push(300);
          st.push(400);
          while (!st.empty())
          {
            cout << st.top()<<" ";
            st.pop();
          }
            return 0;
        }

    image.gif

    image.gif编辑

    这里我们使用的是vector做的底层容器,在std::stack中,底层容器是deque并且支持切换成其他容器,这也就是stack被叫做容器适配器的原因。

    适配器版本:

    容器适配器,我们仅仅需要利用一个类模板参数就可以了,一个类模板参数就可以控制底层存储数据的容器类型,是vector还是list又或者是deque。

    //容器适配器class Container = vector<T>,class Container = list<T>....
        template<class T ,class Container >
      class Stack
      {
      public:
        Stack()
        {}
        const T& top()
        {
          return _v.back();
        }
        void pop()
        {
          return _v.pop_back();
        }
        void push(const T& val)
        {
          _v.push_back(val);
        }
        size_t size()
        {
          return _v.size();
        }
        bool empty()
        {
          return _v.empty();
        }
      private:
        Container _v;
      };
        int main()
        {
          Stack<int,list<int>> st;
          st.push(100);
          st.push(200);
          st.push(300);
          st.push(400);
          while (!st.empty())
          {
            cout << st.top()<<" ";
            st.pop();
          }
            return 0;
        }

    image.gif

    在类模板的哪里也是可以给缺省参数,就可以实现默认存储容器。

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

    image.gif

    image.gif编辑

    四.queue的介绍

    queue-----reference

    1. 队列是一种容器适配器,专门用于在FIFO上下文(先进先出)中操作,其中从容器一端插入元素,另一端提取元素。

    2. 队列作为容器适配器实现,容器适配器即将特定容器类封装作为其底层容器类,queue提供一组特定的成员函数来访问其元素。元素从队尾入队列,从队头出队列。

    3. 底层容器可以是标准容器类模板之一,也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

      • empty:检测队列是否为空
      • size:返回队列中有效元素的个数
      • front:返回队头元素的引用
      • back:返回队尾元素的引用
      • push_back:在队列尾部入队列
      • pop_front:在队列头部出队列

      4. 标准容器类deque和list满足了这些要求。默认情况下,如果没有为queue实例化指定容器类,则使用标准容器deque。

      image.gif编辑

      五. queue使用

      函数声明 接口说明
      queue() 构造空的队列
      empty() 检测队列是否为空,是返回true,否则返回false
      size() 返回队列中有效元素的个数
      front() 返回队头元素的引用
      back() 返回队尾元素的引用
      push() 在队尾将元素val入队列
      pop() 将队头元素出队列

      六.queue模拟实现

      因为queue的接口中存在头删和尾插,因此使用vector来封装效率太低,故可以借助list来模拟实现queue,具体如下:

      普通list版本:

      template<class T>
        class Queue
        {
        public:
          Queue()
          {
          }
          void push(const T& val)
          {
            _q.push_back(val);
          }
          void pop()
          {
            _q.pop_front();
          }
          const T& front()
          {
            return _q.front();
          }
          const T& back()
          {
            return _q.back();
          }
          size_t size()
          {
            return _q.size();
          }
          bool empty()
          {
            return _q.empty();
          }
        private:
          list<T> _q;
        };

      image.gif

      适配器版本:

      template<class T,class Container=list<T>>
        class Queue
        {
        public:
          Queue()
          {
          }
          void push(const T& val)
          {
            _q.push_back(val);
          }
          void pop()
          {
            _q.pop_front();
          }
          const T& front()
          {
            return _q.front();
          }
          const T& back()
          {
            return _q.back();
          }
          size_t size()
          {
            return _q.size();
          }
          bool empty()
          {
            return _q.empty();
          }
        private:
          Container _q;
        };

      image.gif

      image.gif编辑

      七.deque介绍

      1.容器适配器

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

      image.gif编辑

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

      虽然stack和queue中也可以存放元素,但在STL中并没有将其划分在容器的行列,而是将其称为容器适配器,这是因为stack和队列只是对其他容器的接口进行了包装,STL中stack和queue默认使用deque,比如:

      image.gif编辑

      image.gif编辑 2.deque的简单介绍

      deque(双端队列):是一种双开口的"连续"空间的数据结构,双开口的含义是:可以在头尾两端进行插入和删除操作,且时间复杂度为O(1),与vector比较,头插效率高,不需要搬移元素;与list比较,空间利用率比较高。

      image.gif编辑

      image.gif编辑

      同时从库中提供的接口来看,deque还提供了下标的随机访问的功能,但是deque并不是真正连续的空间,而是由一段段连续的小空间拼接而成的,实际deque类似于一个动态的二维数组,其底层结构如下图所示:

      image.gif编辑

      双端队列底层是一段假象的连续空间,实际是分段连续的,为了维护其“整体连续”以及随机访问的假象,落在了deque的迭代器身上,因此deque的迭代器设计就比较复杂,如下图所示:

      image.gif编辑

       3.deque的缺陷

      与vector比较,deque的优势是:头部插入和删除时,不需要搬移元素,效率特别高,而且在扩容时,也不需要搬移大量的元素,因此其效率是比vector高的。与list比较,其底层是连续空间,空间利用率比较高,不需要存储额外字段。

      但是,deque有一个致命缺陷:不适合遍历,因为在遍历时,deque的迭代器要频繁的去检测其是否移动到某段小空间的边界,导致效率低下,而序列式场景中,可能需要经常遍历,因此在实际中,需要线性结构时,大多数情况下优先考虑vector和list,deque的应用并不多,而目前能看到的一个应用就是,STL用其作为stack和queue的底层数据结构。

      4.为什么选择deque作为stack和queue的底层默认容器

      stack是一种后进先出的特殊线性数据结构,因此只要具有push_back()和pop_back()操作的线性结构,都可以作为stack的底层容器,比如vector和list都可以;queue是先进先出的特殊线性数据结构,只要具有push_back和pop_front操作的线性结构,都可以作为queue的底层容器,比如list。但是STL中对stack和queue默认选择deque作为其底层容器,主要是因为:

        1. stack和queue不需要遍历(因此stack和queue没有迭代器),只需要在固定的一端或者两端进行操作。
        2. 在stack中元素增长时,deque比vector的效率高(扩容时不需要搬移大量数据);queue中的元素增长时,deque不仅效率高,而且内存使用率高。

        结合了deque的优点,而完美的避开了其缺陷。

        相关文章
        |
        12天前
        |
        存储 算法 C++
        C++提高篇:泛型编程和STL技术详解,探讨C++更深层的使用
        文章详细探讨了C++中的泛型编程与STL技术,重点讲解了如何使用模板来创建通用的函数和类,以及模板在提高代码复用性和灵活性方面的作用。
        28 2
        C++提高篇:泛型编程和STL技术详解,探讨C++更深层的使用
        |
        2月前
        |
        存储 算法 编译器
        [C++] STL简介
        [C++] STL简介
        26 1
        |
        2月前
        |
        存储 算法 C++
        C++ STL应用宝典:高效处理数据的艺术与实战技巧大揭秘!
        【8月更文挑战第22天】C++ STL(标准模板库)是一组高效的数据结构与算法集合,极大提升编程效率与代码可读性。它包括容器、迭代器、算法等组件。例如,统计文本中单词频率可用`std::map`和`std::ifstream`实现;对数据排序及找极值则可通过`std::vector`结合`std::sort`、`std::min/max_element`完成;而快速查找字符串则适合使用`std::set`配合其内置的`find`方法。这些示例展示了STL的强大功能,有助于编写简洁高效的代码。
        37 2
        |
        2月前
        |
        安全 编译器 容器
        C++STL容器和智能指针
        C++STL容器和智能指针
        |
        2月前
        |
        C++ 容器
        【C++】stack与queue的使用以及模拟实现
        【C++】stack与queue的使用以及模拟实现
        |
        2月前
        |
        算法 安全 Linux
        |
        18天前
        |
        编译器 C++
        C++ 类构造函数初始化列表
        构造函数初始化列表以一个冒号开始,接着是以逗号分隔的数据成员列表,每个数据成员后面跟一个放在括号中的初始化式。
        60 30
        |
        7天前
        |
        并行计算 Unix Linux
        超级好用的C++实用库之线程基类
        超级好用的C++实用库之线程基类
        14 4
        |
        7天前
        |
        C++ Windows
        HTML+JavaScript构建C++类代码一键转换MASM32代码平台
        HTML+JavaScript构建C++类代码一键转换MASM32代码平台
        |
        7天前
        |
        C++
        2合1,整合C++类(Class)代码转换为MASM32代码的平台
        2合1,整合C++类(Class)代码转换为MASM32代码的平台