【C++从入门到放弃】stack和queue的深度剖析及空间适配器的介绍

最新推荐文章于 2024-09-02 20:21:30 发布
最新推荐文章于 2024-09-02 20:21:30 发布
阅读量782 收藏 25
点赞数 26
分类专栏： C++从入门到放弃 文章标签： c++ java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47648037/article/details/131249476
版权

🧑‍💻作者： @情话0.0
📝专栏：《C++从入门到放弃》
👦个人简介：一名双非编程菜鸟，在这里分享自己的编程学习笔记，欢迎大家的指正与点赞，谢谢！

在这里插入图片描述

stack和queue

前言

  此篇博客将谈及到的stack、queue和priority_queue都不是STL的标准容器，而是一种空间适配器。它是通过对一种容器进行封装，并且所有的方法全部由底层依赖的容器进行实现。

一、stack的介绍及使用

1.1 stack的介绍

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

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

  1. 标准容器类vector、deque和list满足这些要求。默认情况下，如果没有为特定堆栈类实例化指定容器类，则使用deque。

1.2 stack的使用

函数说明接口说明
stack()构造空的栈
empty()检测stack是否为空
size()返回stack中元素的个数
top()返回栈顶元素的引用
push()将元素val压入stack中
pop()将stack中尾部的元素弹出
void stack_test()
{
	stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);
	st.push(5);
	st.push(6);
	
	cout << st.top() << endl;
	cout << st.size() << endl;
	cout << st.empty() << endl;
	
	st.pop();
	cout << st.top() << endl;
	cout << st.size() << endl;
	cout << st.empty() << endl;
}

1.3 stack的模拟实现

  根据 stack 的介绍我们知道如果没有为特定堆栈类实例化指定容器类，则使用deque。在stack的模拟实现这一模块使用vector来代替deque作为底层容器，也就是在stack定义的时候要将它的底层容器类型显示给出。

namespace zx
{
	//容器适配器----对已有的容器进行改进
	template<class T,class Container>
	class stack
	{
	public:
		stack()
		{}

		void push(const T& val)
		{
			_con.push_back(val);
		}

		void pop()
		{
			_con.pop_back();
		}

		const T& top()
		{
			return _con.back();
		}

		bool empty()
		{
			return _con.empty();
		}

		size_t size()
		{
			return _con.size();
		}
	private:
		Container _con;
	};

	void test_stack()
	{
		stack<int, vector<int>> st;
		st.push(1);
		st.push(2);
		st.push(3);
		st.push(4);
		st.push(5);

		while (!st.empty())
		{
			cout << st.top() << " ";
			st.pop();
		}
		cout << endl;
	}
}

二、queue的介绍及使用

2.1 queue的介绍

  1. queue是一种容器适配器，专门设计用于在FIFO（先进先出）上下文中操作，其中将元素插入容器的一端并从另一端提取。
  2. queue是作为容器适配器实现的，容器适配器是使用特定容器类的封装对象作为其底层容器的类，提供一组特定的成员函数来访问其元素。元素被推入特定容器的“后面”，并从其“前面”弹出。
  3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

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

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

2.2 queue的使用

函数声明接口说明
queue()构造空的队列
empty()检测队列是否为空，是返回true，否则返回false
size()返回队列中有效元素的个数
front()返回队头元素的引用
back()返回队尾元素的引用
push()在队尾将元素val入队列
pop()将队头元素出队列
void queue_test()
{
	queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.push(4);
	q.push(5);

	cout << q.front() << endl;
	cout << q.back() << endl;
	cout << q.size() << endl;

	q.pop();
	cout << q.front() << endl;
	cout << q.back() << endl;
	cout << q.size() << endl;

	cout << q.empty() << endl;
	return 0;
}

2.3 queue的模拟实现

  和stack一样，如果没有为特定堆栈类实例化指定容器类，则使用deque。因为queue的接口中存在头删和尾插，因此使用vector来封装效率太低，故可以借助list来模拟实现queue，在queue定义的时候要将它的底层容器类型显示给出。

namespace zx
{
	template<class T, class Container>
	class queue
	{
	public:
		queue()
		{}

		void push(const T& val)
		{
			_con.push_back(val);
		}

		void pop()
		{
			_con.pop_front();
		}

		const T& front()
		{
			return _con.front();
		}

		const T& back()
		{
			return _con.back();
		}

		bool empty()
		{
			return _con.empty();
		}

		size_t size()
		{
			return _con.size();
		}
	private:
		Container _con;
	};

	void test_queue()
	{
		queue<int, list<int>> q;
		q.push(1);
		q.push(2);
		q.push(3);
		q.push(4);
		q.push(5);

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

	}
}

三、priority_queue的介绍和使用

3.1 priority_queue的介绍

  1. 优先级队列是一种容器适配器，根据某种严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
  2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大的堆元素(优先级队列中位于顶部的元素)。
  3. 优先级队列是作为容器适配器实现的，这些适配器是使用特定容器类的封装对象作为其底层容器的类，提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，这被称为优先级队列的顶部。
  4. 底层容器可以是任何标准容器类模板或其他特定设计的容器类。容器必须可通过随机访问迭代器访问，并支持以下操作:

empty()：检测容器是否为空
size()：返回容器中有效元素个数
front()：返回容器中第一个元素的引用
push_back()：在容器尾部插入元素
pop_back()：删除容器尾部元素

  1. 标准容器类vector和deque满足这些要求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
  2. 为了始终在内部保持堆结构，需要支持随机访问迭代器。这是由容器适配器在需要时自动调用算法函数make_heap、push_heap和pop_heap自动完成的。

3.2 priority_queue的使用

  优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下priority_queue是大堆。

函数声明接口说明
priority_queue()/priority_queue(first, last)构造一个空的优先级队列
empty( )检测优先级队列是否为空，是返回true，否则返回false
top( )返回优先级队列中最大(最小元素)，即堆顶元素
push(x)在优先级队列中插入元素x
pop()删除优先级队列中最大(最小)元素，即堆顶元素

3.3 priority_queue的模拟实现

  因为优先级队列的底层结构是堆，所以在实现插入删除时就要按照堆的方式完成（向上调整和向下调整）；在这里用到了仿函数的方式来通过一份代码来将优先级队列定义为大堆还是小堆。如果不用仿函数的话则会造成代码的冗余（改变向下调整和向上调整算法的比较大小关系），注意的是在优先级队列的模板参数处，第一个参数是元素类型，第二个是所选择的底层容器（可显示给出，若没显示给出则默认vector），第三个参数则是要建小堆还是大堆的仿函数选择，因为默认是大堆，如果想要将其改成小堆，则需显示给出。同样可说明想要建大堆时那么模板参数的底层容器类型也必须显示给出。还有一点需要注意的就是优先级队列的仿函数模板参数类型默认为less（大堆）。

namespace zx
{
	template<class T>
	struct less
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	template<class T>
	struct greater
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	//大堆
	//template<class T,class Container = vector<T>,class Compare = less<T>>
	//小堆
	template<class T, class Container = vector<T>, class Compare = greater<T>>
	class priority_queue
	{
	public: 
		void adjust_up(int child)
		{
			Compare com;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				if (com(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void adjust_down(size_t parent)
		{
			Compare com;
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
				{
					child += 1;
				}
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
		void push(const T& x)
		{
			_con.push_back(x);
			adjust_up(_con.size()-1);
		}

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

		const T& top()
		{
			return _con[0];
		}

		bool empty()
		{
			return _con.empty();
		}

		size_t size()
		{
			return _con.size();
		}
	private:
		Container _con;
	};
	
	void test_priority_queue()
	{
		//priority_queue<int> pq; 默认-->大堆
		priority_queue<int,deque<int>,greater<int>> pq; //显示构建小堆
		pq.push(1);
		pq.push(3);
		pq.push(8);
		pq.push(0);
		pq.push(7);
		pq.push(6);
		pq.push(4);

		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;
	}
}

  如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供 ‘>’ 或者 ‘<’ 的重载。就拿日期类举例，除了上面的代码还需要一下代码，也可再写出属于自定义类型数据独有的仿函数比较方式。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}

	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}

	friend ostream& operator<<(ostream& _cout, const Date& d)
	{
		_cout << d._year << "-" << d._month << "-" << d._day;
		return _cout;
	}

private:
	int _year;
	int _month;
	int _day;
};

class pDateGreater
{
public:
	bool operator()(const Date* p1, const Date* p2)
	{
		return *p1 > *p2;
	}
};

class pDateLess
{
public:
	bool operator()(const Date* p1, const Date* p2)
	{
		return *p1 < *p2;
	}
};

void test_priority_queue()
{
	//如果还找原来的
	priority_queue<Date, vector<Date>, greater<Date>> q1;
	q1.push(Date(2018, 10, 29));
	q1.push(Date(2018, 10, 30));
	q1.push(Date(2018, 10, 28));
	cout << q1.top() << endl;


	//priority_queue<Date*, vector<Date*>, less<Date*>> q2;
	priority_queue<Date*, vector<Date*>, pDateLess> q2;
	q2.push(new Date(2018, 10, 29));
	q2.push(new Date(2018, 10, 30));
	q2.push(new Date(2018, 10, 28));
	cout << *(q2.top()) << endl;
}

四、容器适配器

4.1 什么是适配器

  适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。
  所以适配器的本质就是将一个原来存在的东西通过某种方式或某个东西转化为另外一种类型的东西，使其具有属于自己独特属性的东西。举个简单例子来看，这就类似于日常生活中的插座一样，将原来220v交流电转化为充电器对应电器合适的电压电流。

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

上面讲到的stack、queue和priority_queue中虽然可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为它们只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，priority_queue默认使用vector。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

五、什么是deque？

5.1 deque的原理

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

在这里插入图片描述

  deque底层空间并不是像上图一样是连续的，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其大致底层结构如下图所示：在map中，每一个空间都指向一段类似定长空间的数组，各个数组之间虽然空间不连续，但是结构上是连续的，当某个数组走到尾部时，再继续往后走一步就会来到下一个数组地头部。

在这里插入图片描述
  双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：我们把map对应的结构称为中控器，每一个空间可称为中控节点，迭代器中node指向中控器的中控节点，first指向中控节点对应缓冲区的起始位置，last指向中控节点对应缓冲区的结束位置，cur指向当前迭代器指针指向的缓冲区的某个元素位置。

在这里插入图片描述

5.2 deque的缺陷

  与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。
  与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。
  但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。
  当初deque被设计出来的时候是想代替vector和list，想让deque同时拥有vector和list的优点，但是历史证明，它的出现并没有激起特别大的浪花，根本威胁不到那两个容器的地位，既没有同时拥有vector和list的优点，而且还拥有特性并没有像它们那么极致。本来想能文能武，结果最后文不行武也不行。

5.3 为什么选择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不仅效率高，而且内存使用率高。

总结

  以上内容就是对于STL中的配接器、空间适配器以及栈和队列的底层默认容器的介绍，整体内容较为简单，大体作为一个了解即可，到此呢针对于STL的学习也到一段落。

情话0.0
关注
  • 26
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 21
    评论
专栏目录
【C++】30h速成C++从入门到精通（stack、queuepriority_queue以及deque介绍）
weixin_59824611的博客
03-06 391
STL中容器适配器相关介绍
【C++】栈和队列（stack&queue）
love_guanghui的博客
12-01 3653
栈和队列 一.stack的介绍和使用 （1）概念 ·stack是一种后进先出的容器结构，准确来说stack并不是容器，而是一种容器适配器（对特定类封装作为其底层的容器）。 ...
【C++】STL——容器适配器 stack和queue 深度剖析及模拟实现 & 适配器模式的了解
m0_70980326的博客
05-18 889
带你认识什么是容器适配器，了解适配器模式，深度剖析STL中的容器适配器stack和queue，并对其进行模拟实现；了解其默认底层容器deque（双端队列）
【C++初阶：STL —— stack and queue】stack/queue的介绍及使用 | stack/queue/priority_queue的深度剖析及模拟实现 | 适配器模式 | 仿函数
wh128341的博客
05-02 1599
虽然 cplusplus 把 stack 和 queue 归类到了 Containers 下，但是严格来说 stack and queue 不再是容器了，而属于容器适配器 or 容器配接器，适配器做的功能是转换 —— 它不是直接实现的，而是由其它容器封装转换实现的，在下面的模拟实现我们会细谈。 它做为容器适配器，它与容器有一个具大的差别之一就是它没有迭代器，不是说它不能实现迭代器，而是没有必要实现迭代器，因为它如果实现了迭代器，就没法保障 stack “Last In First Out” 和 queue
c＋＋STL中stack，queue使用方法和模拟实现，及适配器模式编程
qq_58761784的博客
08-10 1263
1.1 stack的介绍栈是计算机中一个重要的数据结构，因其先进先出的特性，可以解决许多结构上的问题，进行栈的学习，了解它的底层是很有必要的。1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
C++初阶：容器适配器介绍、stack和queue常用接口详解及模拟实现
qq_74415153的博客
02-18 2190
1.stack的初步介绍 2.stack的使用 3.queue的初步介绍 4.queue的使用 5.容器适配器 5.1含义 5.2STL标准库中stack和queue的底层结构 6模拟stack和queue 文件规划和一览 6.1模拟stack (stack.h) 6.2模拟queue (queue.h)
C++ STL容器stack和queue详解
09-01
C++ STL（Standard Template Library，标准模板库）提供了两种特殊的线性容器：stack（栈）和queue（队列），它们都是基于顺序容器（如vector或deque）实现的抽象数据类型，用于实现特定的数据操作逻辑。 **1. ...
初识C++之模拟实现stack、queue和反向迭代器
Masquerena114514的博客
03-12 546
讲解了stl库中的stack和queue的模拟实现、适配器模式、双端队列及反向迭代器的实现和仿函数的概念
c++ vector、stack、queue、map用法总结
yimixgg的博客
04-10 2414
c++ vector、stack、queue、map用法总结 一：vector容器用法总结 参考链接: https://blog.csdn.net/qq_36734094/article/details/79748612#commentBox 在c++中，vector是一个十分有用的容器。 作用：它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能...
c++命令模式
qq_71286244的博客
08-30 3936
c++命令模式详细介绍
c语言赋值截断
hutaotaotao的博客
09-02 415
c语言赋值过程与截断行为
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1193
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 3624
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
C++的内存模型
qhu1600417010的博客
08-28 1155
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
C++友类匿名对象，运算符重载
最新发布
m0_75109289的博客
09-02 115
【代码】C++友类匿名对象，运算符重载。
怎么解决 hash 碰撞，用 C++ 实现 hashMap？
zhanghaiou07657的博客
08-29 2505
如果要自己实现一个简单的哈希映射，可以定义一个结构体来表示哈希表中的节点，包含键值对和指向下一个节点的指针（如果采用链地址法）。在插入操作时，计算键的哈希值，若该位置已被占用且键不相同，则根据选择的解决碰撞的方法（如链地址法）将新元素插入到链表中。在查找操作时，同样计算键的哈希值，然后遍历对应的链表（如果是链地址法）来查找目标键值对。“哈希碰撞是在哈希函数计算过程中可能出现的不同输入产生相同哈希值的情况。链地址法是将哈希值相同的元素存储在一个链表中，当进行查找等操作时，遍历对应的链表来找到目标元素。
C++ | Leetcode C++题解之第390题消除游戏
Ddddddd_158的博客
09-02 76
C++ | Leetcode C++题解之第390题消除游戏
Ascend C算子开发（入门）—— 算子开发初体验
Byyyi耀的博客
08-29 2308
Ascend C算子开发（入门）—— 算子开发初体验
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

情话0.0

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值