queue（队列） 和 stack（栈） 容器详解

一、概念

FIFO queue：

queues 是一种容器适配器，专门设计用于在FIFO上下文中(先进先出）操作，其中元素从容器的一端插入并从另一端提取.

queues 实现为容器适配器，它是使用特定容器类的封装对象作为其底层容器的类，提供一组特定的成员函数来访问其元素。元素被推入特定容器的“后面”并从其“前面” 弹出。

底层容器可以是标准容器类模板之一或其他一些专门设计的容器类。该底层容器应至少支持以下操作：

• empty 
• size
• front
• back
• push_back
• pop_front

标准容器类deque和list满足这些需求。默认情况下，如果没有为特定队列类实例化指定容器类，则使用标准容器deque。

LIFO stack：

栈是一种容器适配器，专门设计用于在LIFO上下文中（后进先出）操作，其中元素仅从容器的一端插入和提取。

stacks 被实现为容器适配器，它是使用特定容器类的封装对象作为其底层容器的类，提供一组特定的成员函数来访问其元素。从特定容器的“后面” 送入 / 弹出元素，该容器称为栈的顶部（top）。

底层容器可以是任何标准容器类模板或一些其他专门设计的容器类。容器应支持以下操作：

• empty
• size
• back
• push_back
• pop_back

二、相关函数对比

member functions
queue		stack
empty	判空	empty	判空
size	元素数量	size	元素数量
front	访问队头元素	top	访问栈顶元素
back	访问对尾元素
push	在对尾压入元素	push	在栈顶压入元素
pop	在对头弹出元素	pop	在栈顶弹出元素

 

注：其中红色字体为接下来详解函数，如果读者想要了解其他函数可以看博主的另一篇文章： https://blog.youkuaiyun.com/qq_41291253/article/details/89840185

三、函数详解

std::queue::front / back

value_type＆front（）;
value_type＆back（）;

访问对首 / 尾元素,返回对队列中对首 / 尾元素的引用。

对首元素是队列中“最老”的元素，当调用queue::pop时，从队列中弹出的元素也是这个元素。

对尾元素是队列中的“最新”元素（即最后一个被推入到队列中的元素）

// queue::front / back
#include <iostream>       // std::cout
#include <queue>          // std::queue

int main ()
{
  std::queue<int> myqueue;

  myqueue.push(77);
  myqueue.push(16);

  myqueue.front() -= myqueue.back();    // 77-16=61

  std::cout << "myqueue.front() is now " << myqueue.front() << '\n';

  return 0;
}
/*===================================
函数输出：myqueue.front() is now 61
===================================*/

std::queue::push / pop

void push（const value_type＆val）;

//val - 插入元素初始化的值。
//成员类型 value_type 是容器中元素的类型（定义为第一个类模板参数的别名，T）

void pop（）;

push：在结尾插入一个新元素 队列，在其当前最后一个元素之后。此新元素的内容初始化为val。

pop：删除队列中的对首元素，使其大小缩小一位。删除的元素是队列中“最老”的元素，其值可以通过调用成员queue::front来检索 。

// queue::push/pop
#include <iostream>       // std::cin, std::cout
#include <queue>          // std::queue

int main ()
{
  std::queue<int> myqueue;
  int myint;

  std::cout << "Please enter some integers (enter 0 to end):\n";

  do {
    std::cin >> myint;
    myqueue.push (myint);
  } while (myint);

  std::cout << "myqueue contains: ";
  while (!myqueue.empty())
  {
    std::cout << ' ' << myqueue.front();
    myqueue.pop();
  }
  std::cout << '\n';

  return 0;
}

std::stack::top

value_type＆front（）;

访问栈顶元素，返回栈顶元素的引用。

由于栈是后进先出容器，因此顶部元素是插入栈的最后一个元素。

// stack::top
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
  std::stack<int> mystack;

  mystack.push(10);
  mystack.push(20);

  mystack.top() -= 5;

  std::cout << "mystack.top() is now " << mystack.top() << '\n';

  return 0;
}

//output:
//mystack.top() is now 15

std::stack::push / pop

void push（const value_type＆val）;

//val - 插入元素初始化的值。
//成员类型 value_type 是容器中元素的类型（定义为第一个类模板参数的别名，T）

void pop（）;

push：插入元素，在栈顶部插入一个新元素，高于其目前的顶级元素。此新元素的内容初始化为val的副本

pop：删除元素，删除栈顶元素

// stack::push/pop
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
  std::stack<int> mystack;

  for (int i=0; i<5; ++i) mystack.push(i);

  std::cout << "Popping out elements...";
  while (!mystack.empty())
  {
     std::cout << ' ' << mystack.top();
     mystack.pop();
  }
  std::cout << '\n';

  return 0;
}

//output:
//Popping out elements... 4 3 2 1 0