C++ stack和queue的使用方法与模拟实现

---

一、 stack的使用方法

stack介绍文档

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。
2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：

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

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

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

#include<iostream>
#include<stack>
#include<queue>
using namespace std;
int main()
{
	stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);
	cout << "容量是：" << st.size() << endl;
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
	cout << "容量是：" << st.size() << endl;
	return 0;
}

二、 queue的使用方法

queue的介绍文档

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。
3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

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

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

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

#include<iostream>
#include<stack>
#include<queue>
using namespace std;
int main()
{
	queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.push(4);
	cout << "容量是：" << q.size() << endl;
	while (!q.empty())
	{
		cout << q.front() << " ";
		q.pop();
	}
	cout << endl;
	cout << "容量是：" << q.size() << endl;
	return 0;
}

三、 容器适配器

C++ STL (Standard Template Library) 中的容器适配器是一种特殊的容器，它们通过封装和扩展其他容器（如 std::vector、std::list 或 std::deque）的功能来提供额外的功能或接口。容器适配器本身并不存储数据，而是将它们的工作委托给基础容器。

C++ STL 提供了三种主要的容器适配器：

1. std::stack

   • 提供了后进先出（LIFO）的数据结构。
   • 主要操作包括 push（添加元素到栈顶）、pop（从栈顶删除元素）、top（访问栈顶元素但不删除）和 empty（检查栈是否为空）等。
   • 默认情况下，std::stack 使用 std::deque 作为其底层容器，但你可以通过模板参数指定其他容器。

2. std::queue

   • 提供了先进先出（FIFO）的数据结构。
   • 主要操作包括 push（在队尾添加元素）、pop（从队头删除元素）、front（访问队头元素但不删除）、back（访问队尾元素但不删除）和 empty（检查队列是否为空）等。
   • 默认情况下，std::queue 使用 std::deque 作为其底层容器，但同样可以指定其他容器。

3. std::priority_queue

   • 提供了带有优先级队列的数据结构，其中元素总是按优先级排序（默认情况下是最大堆）。
   • 主要操作包括 push（添加元素并重新排序）、pop（删除最高优先级的元素并重新排序）、top（访问最高优先级的元素但不删除）和 empty（检查队列是否为空）等。
   • std::priority_queue 还允许你指定比较函数或函数对象，以定义元素的优先级顺序。

使用容器适配器的好处是它们提供了简洁、易于使用的接口，同时允许你使用任何符合要求的底层容器。这使得你可以轻松地更改底层容器的实现，而无需修改使用容器适配器的代码。

四、 stack的模拟实现

在stack类模板声明当中的模板参数有两个，第一个是stack当中所存储的元素类型，第二个就是指定使用的容器类型。如果不指定使用什么容器的话，stack默认使用deque

函数说明	接口说明	实现方法
swap()	交换两个栈中的数据	调用指定容器的swap()函数
empty()	检测stack是否为空	调用指定容器的empty()函数
size()	返回stack中元素的个数	调用指定容器的size()函数
top()	返回栈顶元素的引用	调用指定容器的back()函数
push()	将元素val压入stack中	调用指定容器的oush_back()函数
pop()	将元素val压入stack中	调用指定容器的pop_back()函数

代码实现如下：

#pragma once
#include<vector>
#include<list>
#include<deque>

namespace hao
{
	//template<class T,class Container=std::vector<T> >
	template<class T, class Container = std::deque<T> >
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_back();
		}
		size_t size()
		{
			return _con.size();
		}
		T& top()
		{
			return _con.back();
		}
		bool empty()
		{
			return _con.empty();
		}
		void swap(const stack<T,Container>& st )
		{
			_con.swap(st._con);
		}
	private:
		Container _con;
	};
	void test_stack()
	{
		//stack<int, vector<int>> st1;
		stack<int> st1;
		st1.push(1);
		st1.push(2);
		st1.push(3);
		st1.push(4);

		while (!st1.empty())
		{
			std::cout << st1.top() << " ";
			st1.pop();
		}
		std::cout << std::endl;

		stack<int, std::list<int>> st2;
		st2.push(1);
		st2.push(2);
		st2.push(3);
		st2.push(4);

		while (!st2.empty())
		{
			std::cout << st2.top() << " ";
			st2.pop();
		}
		std::cout << std::endl;
	}
}

五、 queue的模拟实现

在queue类模板声明当中的模板参数有两个，第一个是queue当中所存储的元素类型，第二个就是指定使用的容器类型。如果不指定使用什么容器的话，queue默认使用deque

函数说明	接口说明	实现方法
swap	交换两个队列中的数据	调用指定容器的swap()函数
empty()	检测队列是否为空，是返回true，否则返回false	调用指定容器的empty()函数
size()	返回队列中有效元素的个数	调用指定容器的size()函数
front()	返回队头元素的引用	调用指定容器的front()函数
back()	返回队尾元素的引用	调用指定容器的back()函数
push()	在队尾将元素val入队列	调用指定容器的push_back()函数
pop()	将队头元素出队列	调用指定容器的pop_front()函数

代码实现如下：

#pragma once
#include<list>
#include<deque>

namespace hao
{
	//template<class T,class Container=std::list<T> >
	template<class T, class Container = std::deque<T> >
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_front();
		}
		size_t size()
		{
			return _con.size();
		}
		T& front()
		{
			return _con.front();
		}
		T& back()
		{
			return _con.back();
		}
		bool empty()
		{
			return _con.empty();
		}
		void swap(queue<T, Container>& q)
		{
			_con.swap(q._con);
		}
	private:
		Container _con;
	};
	void test_queue()
	{
		queue<int, std::list<int>> q;

		//queue<int, vector<int>> q;
		q.push(1);
		q.push(2);
		q.push(3);
		q.push(4);

		while (!q.empty())
		{
			std::cout << q.front() << " ";
			q.pop();
		}
		std::cout << std::endl;
	}
}