STL之stack 和 queue

这两种容器在STL中被称为是适配器，是对deque的一种限制容器，操作仅仅可以在头部或者是尾部进行。

STL中的stack默认是用deque来实现的，但是我觉得用list实现第更高效一点，简单的slist就可以这样做。

当然也可以使用vector来进行实现，不过vector的生长确实是要考虑的范畴，因此觉得单纯的stack用单向列表进行实现就很好了。

template <class _Tp, class _Sequence>
class stack {

  // requirements:

  __STL_CLASS_REQUIRES(_Tp, _Assignable);
  __STL_CLASS_REQUIRES(_Sequence, _BackInsertionSequence);
  typedef typename _Sequence::value_type _Sequence_value_type;
  __STL_CLASS_REQUIRES_SAME_TYPE(_Tp, _Sequence_value_type);

#ifdef __STL_MEMBER_TEMPLATES
  template <class _Tp1, class _Seq1>
  friend bool operator== (const stack<_Tp1, _Seq1>&,
                          const stack<_Tp1, _Seq1>&);
  template <class _Tp1, class _Seq1>
  friend bool operator< (const stack<_Tp1, _Seq1>&,
                         const stack<_Tp1, _Seq1>&);
#else /* __STL_MEMBER_TEMPLATES */
  friend bool __STD_QUALIFIER
  operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&);
  friend bool __STD_QUALIFIER
  operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&);
#endif /* __STL_MEMBER_TEMPLATES */

public:
    // 由于stack仅支持对栈顶元素的操作, 所以不定义STL要求的
    // pointer, iterator, difference_type
  typedef typename _Sequence::value_type      value_type;
  typedef typename _Sequence::size_type       size_type;
  typedef          _Sequence                  container_type;

  typedef typename _Sequence::reference       reference;
  typedef typename _Sequence::const_reference const_reference;
protected:
  _Sequence c;//底层容器类型，默认为deque容器
public:
    //下面对stack的维护完全依赖于底层容器的操作
  stack() : c() {}
  explicit stack(const _Sequence& __s) : c(__s) {}

  //判断容器是否为空
  bool empty() const { return c.empty(); }
  //获取容器的大小，即容器中元素的个数
  size_type size() const { return c.size(); }
  //返回栈顶元素的引用
  reference top() { return c.back(); }
  const_reference top() const { return c.back(); }
  //在栈顶追加元素
  void push(const value_type& __x) { c.push_back(__x); }
  //弹出栈顶的元素，但不返回任何内容
  void pop() { c.pop_back(); }
};

template <class _Tp, class _Sequence>
class stack {

  // requirements:

  __STL_CLASS_REQUIRES(_Tp, _Assignable);
  __STL_CLASS_REQUIRES(_Sequence, _BackInsertionSequence);
  typedef typename _Sequence::value_type _Sequence_value_type;
  __STL_CLASS_REQUIRES_SAME_TYPE(_Tp, _Sequence_value_type);

#ifdef __STL_MEMBER_TEMPLATES
  template <class _Tp1, class _Seq1>
  friend bool operator== (const stack<_Tp1, _Seq1>&,
                          const stack<_Tp1, _Seq1>&);
  template <class _Tp1, class _Seq1>
  friend bool operator< (const stack<_Tp1, _Seq1>&,
                         const stack<_Tp1, _Seq1>&);
#else /* __STL_MEMBER_TEMPLATES */
  friend bool __STD_QUALIFIER
  operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&);
  friend bool __STD_QUALIFIER
  operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&);
#endif /* __STL_MEMBER_TEMPLATES */

public:
    // 由于stack仅支持对栈顶元素的操作, 所以不定义STL要求的
    // pointer, iterator, difference_type
  typedef typename _Sequence::value_type      value_type;
  typedef typename _Sequence::size_type       size_type;
  typedef          _Sequence                  container_type;

  typedef typename _Sequence::reference       reference;
  typedef typename _Sequence::const_reference const_reference;
protected:
  _Sequence c;//底层容器类型，默认为deque容器
public:
    //下面对stack的维护完全依赖于底层容器的操作
  stack() : c() {}
  explicit stack(const _Sequence& __s) : c(__s) {}

  //判断容器是否为空
  bool empty() const { return c.empty(); }
  //获取容器的大小，即容器中元素的个数
  size_type size() const { return c.size(); }
  //返回栈顶元素的引用
  reference top() { return c.back(); }
  const_reference top() const { return c.back(); }
  //在栈顶追加元素
  void push(const value_type& __x) { c.push_back(__x); }
  //弹出栈顶的元素，但不返回任何内容
  void pop() { c.pop_back(); }
};

template <class _Tp, class _Sequence>
class stack {

  // requirements:

  __STL_CLASS_REQUIRES(_Tp, _Assignable);
  __STL_CLASS_REQUIRES(_Sequence, _BackInsertionSequence);
  typedef typename _Sequence::value_type _Sequence_value_type;
  __STL_CLASS_REQUIRES_SAME_TYPE(_Tp, _Sequence_value_type);

#ifdef __STL_MEMBER_TEMPLATES
  template <class _Tp1, class _Seq1>
  friend bool operator== (const stack<_Tp1, _Seq1>&,
                          const stack<_Tp1, _Seq1>&);
  template <class _Tp1, class _Seq1>
  friend bool operator< (const stack<_Tp1, _Seq1>&,
                         const stack<_Tp1, _Seq1>&);
#else /* __STL_MEMBER_TEMPLATES */
  friend bool __STD_QUALIFIER
  operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&);
  friend bool __STD_QUALIFIER
  operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&);
#endif /* __STL_MEMBER_TEMPLATES */

public:
    // 由于stack仅支持对栈顶元素的操作, 所以不定义STL要求的
    // pointer, iterator, difference_type
  typedef typename _Sequence::value_type      value_type;
  typedef typename _Sequence::size_type       size_type;
  typedef          _Sequence                  container_type;

  typedef typename _Sequence::reference       reference;
  typedef typename _Sequence::const_reference const_reference;
protected:
  _Sequence c;//底层容器类型，默认为deque容器
public:
    //下面对stack的维护完全依赖于底层容器的操作
  stack() : c() {}
  explicit stack(const _Sequence& __s) : c(__s) {}

  //判断容器是否为空
  bool empty() const { return c.empty(); }
  //获取容器的大小，即容器中元素的个数
  size_type size() const { return c.size(); }
  //返回栈顶元素的引用
  reference top() { return c.back(); }
  const_reference top() const { return c.back(); }
  //在栈顶追加元素
  void push(const value_type& __x) { c.push_back(__x); }
  //弹出栈顶的元素，但不返回任何内容
  void pop() { c.pop_back(); }
};

又想说C++中模板类的强大了。真是牛逼的思想。

queue和stack一样，也是受限制操作的容器。

template <class _Tp, class _Sequence>
class queue {

  // requirements:

  __STL_CLASS_REQUIRES(_Tp, _Assignable);
  __STL_CLASS_REQUIRES(_Sequence, _FrontInsertionSequence);
  __STL_CLASS_REQUIRES(_Sequence, _BackInsertionSequence);
  typedef typename _Sequence::value_type _Sequence_value_type;
  __STL_CLASS_REQUIRES_SAME_TYPE(_Tp, _Sequence_value_type);

#ifdef __STL_MEMBER_TEMPLATES
  template <class _Tp1, class _Seq1>
  friend bool operator== (const queue<_Tp1, _Seq1>&,
                          const queue<_Tp1, _Seq1>&);
  template <class _Tp1, class _Seq1>
  friend bool operator< (const queue<_Tp1, _Seq1>&,
                         const queue<_Tp1, _Seq1>&);
#else /* __STL_MEMBER_TEMPLATES */
  friend bool __STD_QUALIFIER
  operator== __STL_NULL_TMPL_ARGS (const queue&, const queue&);
  friend bool __STD_QUALIFIER
  operator<  __STL_NULL_TMPL_ARGS (const queue&, const queue&);
#endif /* __STL_MEMBER_TEMPLATES */

public:
    // queue仅支持对头部和尾部的操作, 所以不定义STL要求的
  // pointer, iterator, difference_type
  typedef typename _Sequence::value_type      value_type;
  typedef typename _Sequence::size_type       size_type;
  typedef          _Sequence                  container_type;

  typedef typename _Sequence::reference       reference;
  typedef typename _Sequence::const_reference const_reference;
protected:
  _Sequence c;//底层容器，默认为deque容器，用户可自行指定容器类型
public:
    //下面对queue的维护完全依赖于底层容器的操作
  queue() : c() {}
  explicit queue(const _Sequence& __c) : c(__c) {}

  //判断容器是否为空
  bool empty() const { return c.empty(); }
  //返回容器中元素的个数
  size_type size() const { return c.size(); }
  //返回队头元素的引用
  reference front() { return c.front(); }
  const_reference front() const { return c.front(); }
  //返回队尾元素的引用
  reference back() { return c.back(); }
  const_reference back() const { return c.back(); }
  //只能在队尾新增元素
  void push(const value_type& __x) { c.push_back(__x); }
  //只能在队头移除元素
  void pop() { c.pop_front(); }
};

queue也可以使用双向循环列表来实现，也就是STL中的list来实现。

在刷题的时候这两中数据结构用的还是挺多的。

原文地址：https://www.cnblogs.com/randyniu/p/9249468.html

时间： 2024-10-16 05:03:27

STL之stack 和 queue的相关文章

STL学习——Stack/Queue篇

STL学习--Stack/Queue篇 Stack 概述 stack是一种先进先出的数据结构,只有一个出口,stack允许新增元素,移除元素,取得最顶端元素.但除了最顶端外,没有任何办法可以存取stack其他元素.即不允许遍历行为. 实现 stack实现是以容器为底部结构的,将容器的接口改变,使其符合"先进先出"特性,便形成了一个栈.具体实现可以将底部deque的头端开口封闭,便实现了stack.因为stack具有"修改某物接口,形成另一种风貌"性质,故称为&quo

STL之stack容器和queue容器

摘要:本文主要介绍了两种容器——stack容器和queue容器. 1.基本概念 stack容器 queue容器容器介绍 stack是一种先进后出(First In Last Out,FILO)的数据结构,它只有一个出口, 形式如图所示.stack容器允许新增元素,移除元素,取得栈顶元素,但是除了最顶端外,没有任何其他方法可以存取stack的其他元素.换言之,stack不允许有遍历行为. 有元素推入栈的操作称为:push,将元素推出stack的操作称为pop. Queue是一种先进先出(

STL之容器适配器queue的实现框架

说明:本文仅供学习交流,转载请标明出处,欢迎转载! 上篇文章STL之容器适配器stack的实现框架已经介绍了STL是如何借助基础容器实现一种常用的数据结构stack (栈),本文介绍下另外一种STL内部定义的另外一种STL容器适配器queue(队列). 对于接触过数据结构的人来说,队列并不陌生,它是一种FIFO(first in first out)的数据结构.与栈相比,队列的不同之处在于:(1)队列是一种先进先出的数据结构,而栈则是一种后进先出的数据结构:(2)队列支持首尾两端的访问操作,而栈

STL之stack适配器的实现框架

说明:本文仅供学习交流,转载请标明出处,欢迎转载! 一提到适配器(adapter),我们就想到了早期用电话线上网所用的调制解调器,俗称"猫","猫"的作用是实现数模转化和模数转化,在客户端,它可以将电话的模拟信息转化为我们计算机能够接收的数字信息,所以猫相当于一个转换器.再举个更加好理解的例子来说明"适配器"的含义.相信在我们每个人的家里都有插排,假设就这么一种情况,现在我们家里的墙壁上只有一个三角的插口,而我们的电视却是两个口,怎么办?毫无疑问

C++ STL学习——stack

栈是最为常用的数据结构了,很多算法都是依靠栈来实现的,比如递归.我们要手动来实现栈,显得十分繁琐和麻烦,而且复用性不好.C++ 的STL中已经帮我们封装好了栈,我们只要方便的进行调用即可.该篇博客主要介绍STL 中stack的使用,stack应该说是STL中最简单的容器了.实例代码上传至 https://github.com/chenyufeng1991/STL_stack . (1)首先引入头文件 #include <stack> .并使用命名空间:using namespace st

C++ Primer 学习笔记_55_STL剖析（十）：容器适配器（stack、 queue 、priority_queue）源码浅析与使用示例

七种基本容器:vector.deque.list.set.multiset.map.multimap 一.容器适配器 stack queue priority_queue stack.queue.priority_queue 都不支持任一种迭代器,它们都是容器适配器类型,stack是用vector/deque/list对象创建了一个先进后出容器:queue是用deque或list对象创建了一个先进先出容器:priority_queue是用vector/deque创建了一个排序队列,内部用二叉堆实

STL 之 stack 源码剖析

G++ 2.91.57,cygnus\cygwin-b20\include\g++\stl_stack.h 完整列表 /* * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fe

java中List、Map、Set、Collection、Stack、Queue等的使用

java中这几个东西是比较常用的,虽然我用的不多,也正是因为用的不多,所以我一直搞不清楚他们之间的具体用法以及相互之间的关系,现在特单独作为一个东西来总结一下. 本文参考一下资料: 1.<java编程思想>一书第11章 2.http://blog.sina.com.cn/s/blog_a345a8960101k9vx.html 3.http://f51889920.iteye.com/blog/1884810 4.http://blog.csdn.net/speedme/article/det

特殊集合（stack、queue、hashtable的示例及练习）

特殊集合:stack,queue,hashtable stack:先进后出,一个一个的赋值一个一个的取值,按照顺序. .count 取集合内元素的个数 .push() 将元素一个一个推入集合中 .pop() 将元素一个个弹出集合 .clear() 清空集合 queue:先进先出,一个一个的赋值一个一个的取值,按照顺序. .count 取集合内元素的个数 .Enqueue() 进队列集合 .