stack和queue

news2024/10/7 10:17:00

stack：https://cplusplus.com/reference/stack/stack/?kw=stack

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

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

3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下 操作： empty：判空操作 back：获取尾部元素操作 push_back：尾部插入元素操作 pop_back：尾部删除元素操作

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

文档中我们发现：stack和queue的接口少了许多，没有了迭代器（这是因为要保持他们的特性）

如果有了迭代器的话，就可以直接遍历，失去了这两个数据结构的特性 ；

栈：是先进后出

队列：先进先出

stack的使用

#pragma once
#include<iostream>
#include<vector>
#include<deque>
using namespace std;

namespace lrx
{
   template<class T,class Container=deque<T>>
   //通过访问STL库我们发现在这里的cointainer这里的模板有一个缺省值，是deque，他也是一个容器，
   //通过查询我们发现他的接口比起vector跟list来说多了一个头插头删，更加的全能
   class stack
	   //相当于对vector进行了一个简单的封装
   {
   public:
	   void push(const T&x)
	   {
		   _con.push_back(x);

	   }
	   void pop()
	   {
		   _con.pop_back();
	   }
	   T& top()
	   {
		   return _con.back();
	   }
	   T& top()const
	   {
		   _con.back();
	   }
	   bool empty() const
	   {
		   return _con.empty();
	   }
	   size_t size() const
	   {
		   return _con.size();
	   }
   private:
	   //vector<T> _con;
	   Container _con;//不需要知道container是谁，只需要知道他是一个容器
	   //这里就是container（转接器）的意义，只用vector的话他就是顺序栈。但是链表栈也是存在的，所以底层也可以给一个容器，
	   //给哪个就用哪个
   };
   void test_stack1()
   {
	   //lrx::stack<int, vector<int>> st;
	   lrx::stack<int> st;
	   st.push(1);
	   st.push(2);
	   st.push(3);
	   st.push(4);
	   while (!st.empty())
	   {
		   cout << st.top() << " ";
		   st.pop();
	   }

   }
}

2. queue的介绍和使用

2.1 queue的介绍

queue的文档介绍 翻译：

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

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

3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操 作: empty：检测队列是否为空 size：返回队列中有效元素的个数 front：返回队头元素的引用 back：返回队尾元素的引用 push_back：在队列尾部入队列 pop_front：在队列头部出队列

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

queue 的使用

https://cplusplus.com/reference/queue/queue/

#pragma once
#include<iostream>
#include<deque>
using namespace std;

namespace lrx
{
	template<class T,class Container=deque<T>>
	class queue
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}

		void pop()
		{
			_con.pop_front();
		}
		T& back()const 
		{
			return _con.back();
		}
		T& front()
		{
			return _con.front();
		}
		bool empty()const
		{
			return _con.empty();
		}
		size_t size()
		{
			return _con.size();
		}
	private:
		Container _con;
	};
	void test_queue1()
	{
		lrx::queue<int> q1;
		q1.push(1);
		q1.push(2);
		q1.push(3);
		q1.push(4);

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

deque：

https://cplusplus.com/reference/deque/deque/

deque真正适合的场景：尾插尾删多，任意的访问就得用vector，任意位置要插入删除，中间位置也要，就得用list，deque适合头尾的插入删除，相比vector和list而言，vector每次头插都要挪动空间，list每次都要创造一个新节点，缓存利用率高，所以deque很适合做stack和deque的默认适配容器，如果是中间插入删除，直接用list，随机访问多就用vector；

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

 priority_queue的介绍和使用：

https://cplusplus.com/reference/queue/priority_queue/

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元 素)。

3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特 定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭 代器访问，并支持以下操作：

empty()：检测容器是否为空

size()：返回容器中有效元素个数

front()：返回容器中第一个元素的引用

push_back()：在容器尾部插入元素

pop_back()：删除容器尾部元素

优先级队列的模拟实现：

再模拟实现之前，我们要引入仿函数的观点：

如果没用仿函数的引用进去，实现的优先级队列如下所示（举大堆的例子）

#pragma once
#include<iostream>
#include<vector>
using namespace std;

namespace lrx
{
	//大堆(我们如果想建小堆总不能进函数里来通过改变函数的结果来完成目的，失去了封装性的意义，应该再提供一个接口（仿函数））
	template<class T,class Container=vector<T>>
	class priority_queue
	{
	public:
		priority_queue()//这里写构造函数的原因是：迭代器区间的构造也算是函数的构造
//类和对象中我们了解到，如果一旦我们写了函数的构造函数，则不会生成构造函数，使用自己写的
//这里差了一个空的构造函数，我们自己补上，后面就会调用_con对应的构造函数
		{}
		template<class InputIterator>
		//迭代器区间的构造
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}
			//建堆（向下建堆）
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; --i)
			{
				AdjustDown(i);
			}
		}
		void AdjustUp(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child>=0)//最坏的情况就是调整树的高度次数，logN
			{
				if (_con[child] > _con[parent])
				{
					std::swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}//插入就可以看的出是一个logN的时间复杂度
		void push(const T&x)//向上调整
		{
			_con.push_back(x);
			AdjustUp(_con.size()-1);
		}
		//向下调整最多也是高度次logN
		void AdjustDown(size_t parent)
		{
			size_t child = parent * 2 + 1;
			while (child < _con.size())//找左右孩子大的那一个，先找左孩子，<size：是因为堆空间上看是一个数组，如果找完数组都没有找到则不存在
			{
				//选出左右孩子更大的那一个
				if (child + 1 < _con.size()&&_con[child+1>_con[child]])//找左右孩子更大的那一个，右孩子可能不存在，左孩子存在右孩子不一定存在
					//且如果右孩子大于左孩子
				{
					++child;
				}//这一段逻辑是默认是指向左孩子的，如果右孩子大于左孩子指向右孩子，如果是小于就指向左孩子
				if (_con[child] > _con[parent])
				{
					std::swap(_con[child], _con[parent]);
					//向下走：
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
			const T& top()
			{
				return _con[0];
			}
		}
		//删除可以看出也是个logN的算法
		void pop()//向下调整
		{
			//逻辑上是一个二叉树，物理上是一个数组，不能像vector一样挪动删除，而应该堆顶跟最后一个数据交换，之后尾删
			//这时候左子树依旧是小堆，右子树也是小堆，之后向下排序一下就行。

			std::swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			AdjustDown();

		}
const T& top()
		{
			return _con[0];
		}
		bool empty()
		{
			return _con.empty();
		}
		size_t size()
		{
			return _con.size();
		}
	private:
		Container _con;
	};
	void prioriy_queue_test1()
	{
		priority_queue<int> pq;
		pq.push(3);
		pq.push(4);
		pq.push(6);
		pq.push(2);
		pq.push(8);
		pq.push(0);
		pq.push(7);
        while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;

		

	}
}

这里我们提出如果想建立小堆，不可能把函数里面的建堆接口的大小于号，c++仿函数就是用来解决这个问题的

仿函数：

//仿函数，也叫函数对象，其实是一个类，这个类重载了operator()，
namespace lrx
{
	struct less//写一个比较大小的(小于的)
	{
		bool operator()(const int& l, const int& r)const//参数取决于要干什么，比较大小的话就给两个变量
		{
			return l < r;
		}
	};
}
int main()
{
	lrx::less lsFunc;
	cout << lsFunc(1, 2) << endl;
	//这里的lsFunc是一个类对象可以像函数一样去使用
	//本质上是lsFunc.operator（）（1，2）
	return 0;
}

经过仿函数的改造之后我们发现我们可以跟STL库里面的优先级队列一样控制参数从而达到建大堆还是小堆；

下面是代码实现：

#pragma once
#include<iostream>
#include<vector>
using namespace std;

namespace lrx
{
	//大堆(我们如果想建小堆总不能进函数里来通过改变函数的结果来完成目的，失去了封装性的意义，应该再提供一个接口（仿函数））
	//Compare 进行比较的仿函数，less是大堆，greater是小堆
	template<class T, class Container = vector<T>, class Compare=std::less<T> >
	class priority_queue
	{
	public:
		priority_queue()
		{}
		template<class InputIterator>
		//迭代器区间的构造
		priority_queue(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}
			//建堆（向下建堆）
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; --i)
			{
				AdjustDown(i);
			}
		}
		void AdjustUp(size_t child)
		{
			Compare com;
			size_t parent = (child - 1) / 2;
			while (child>0)//最坏的情况就是调整树的高度次数，logN
			{
				//if (_con[child] > _con[parent])
				//if(_con[parent]<_con[child])//用小于实现大堆
				if(com(_con[parent],_con[child]))
				{
					std::swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}//插入就可以看的出是一个logN的时间复杂度
		void push(const T&x)//向上调整
		{
			_con.push_back(x);
			AdjustUp(_con.size()-1);
		}
		//向下调整最多也是高度次logN
		void AdjustDown(size_t parent)
		{
			Compare com;
			size_t child = parent * 2 + 1;
			while (child < _con.size())//找左右孩子大的那一个，先找左孩子，<size：是因为堆空间上看是一个数组，如果找完数组都没有找到则不存在
			{
				
				//选出左右孩子更大的那一个
				//if (child + 1 < _con.size()&&_con[child+1>]_con[child])//找左右孩子更大的那一个，右孩子可能不存在，左孩子存在右孩子不一定存在
					//且如果右孩子大于左孩子
				//if(_chlid+1<_con.size()&&_con[child]<_con[child+1])
				if(child+1<_con.size() && com(_con[child], _con[child + 1]))
				{
					++child;
				}

				//这一段逻辑是默认是指向左孩子的，如果右孩子大于左孩子指向右孩子，如果是小于就指向左孩子
				//if (_con[child] > _con[parent])
				//if(_con[parent]<_con[child])
				if(com(_con[parent],_con[child]))
				{
					std::swap(_con[child], _con[parent]);
					//向下走：
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
			
			
		}
		//删除可以看出也是个logN的算法
		void pop()//向下调整
		{
			//逻辑上是一个二叉树，物理上是一个数组，不能像vector一样挪动删除，而应该堆顶跟最后一个数据交换，之后尾删
			//这时候左子树依旧是小堆，右子树也是小堆，之后向下排序一下就行。

			std::swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			AdjustDown(0);

		}
		const T& top()
		{
			return _con[0];
		}
		bool empty()
		{
			return _con.empty();
		}
		size_t size()
		{
			return _con.size();
		}
	private:
		Container _con;
	};
	void prioriy_queue_test1()
	{
		priority_queue<int> pq;
		pq.push(3);
		pq.push(4);
		pq.push(6);
		pq.push(2);
		pq.push(8);
		pq.push(0);
		pq.push(7);
		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;

	}
	void prioriy_queue_test2() 
	{
		vector<int>v1;
		v1.push_back(3);
		v1.push_back(1);
		v1.push_back(5);
		v1.push_back(8);
		v1.push_back(2);
		v1.push_back(19);

		priority_queue<int,vector<int>,greater<int>> pq(v1.begin(),v1.end());
		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}


	}
}

仿函数默认是库里面的less（大堆），这里的less跟greater有一点反人类，正好对应相反的堆；

改造函数的过程：

先在模板处增加一个class Compare=std::less<T> ，之后再每个建堆的adjust里面创建com对象

先把if整体的格式变成默认的小于号建大堆（这样做符合库里面less表示大堆的过程），之后将com写成仿函数的方式，将大小比较的两个作为参数传入，即改造完成。这么是泛型编程的经典实现，通过控制com来控制大堆还是小堆。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/101884.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

设计模式之命令模式

设计模式之命令模式

Command design pattern 命令模式的概念、命令模式的结构、命令模式的优缺点、命令模式的使用场景、命令模式的实现示例、命令模式的源码分析 1、命令模式的概念 命令模式&#xff0c;即将请求封装成一个对象&#xff0c;使发出请求的责任和执行请求的责任分离开。这样两者之间…
阅读更多...
App自动化测试【1】Appium的原理解读

App自动化测试【1】Appium的原理解读

1.Appium的架构原理 Appium的架构原理如图所示&#xff0c;由客户端&#xff08;Appium Client&#xff09;和服务器&#xff08;Appium Server&#xff09;两部分组成&#xff0c;客户端与服务器端通过JSON Wire Protocol进行通信。 2.Appium原理解读 客户端Client&#x…
阅读更多...
Win10自动更新怎么永久关闭？服务、注册表、组策略、计划任务中全方位设置，永久解决！

Win10自动更新怎么永久关闭？服务、注册表、组策略、计划任务中全方位设置，永久解决！

Win10自动更新就像打不死的小强&#xff0c;不管怎么关闭&#xff0c;之后还是会自动更新&#xff0c;让不少小伙伴颇为不爽。今天通过4步&#xff0c;在服务、注册表、组策略、计划任务中全方位设置&#xff0c;彻底关闭Win10自动更新&#xff0c;感兴趣的小伙伴不妨试试吧。 …
阅读更多...
Python：requirements.txt, environment.yml简介

Python：requirements.txt, environment.yml简介

文章目录简介requirements.txtenvironment.yml小结简介 最近安装了一些从github上clone下载的开源python软件包&#xff0c;经历了许许多多的酸甜苦辣。在python软件包&#xff0c;通常都会包含requirements.txt, environment.yml, setup.py三者之中某些或者全部&#xff0c;一…
阅读更多...
11.注解开发依赖注入及管理第三方Bean

11.注解开发依赖注入及管理第三方Bean

1. 注解开发依赖注入 1.1 使用Autowired注解开启自动装配模式 Service public class BookServiceImpl implements BookService {//Autowired&#xff1a;注入引用类型&#xff0c;自动装配模式&#xff0c;默认按类型装配Autowiredprivate BookDao bookDao;public void save(…
阅读更多...
【OpenCV+Qt】实现简易视频播放器——支持进度条拖动

【OpenCV+Qt】实现简易视频播放器——支持进度条拖动

OpenCV实现视频播放器&#xff0c;其思路大致就是在线程中使用OpenCV中的VideoCapture循环读取本地视频的每一帧Mat&#xff0c;然后发送到界面转换成QImage进行显示&#xff0c;而进度条拖动则用到了VideoCapture中的set函数&#xff0c;进度条则是使用Qslider&#xff1b;并且…
阅读更多...
记录安装 fenics 的问题

记录安装 fenics 的问题

因为 fenics 官方更新后可能版本会出现有时效的问题, 所以也记录一下时间. Windows 系统下安装最大的问题 2022-12-19 记录. Windows 系统下本来是想通过 Anaconda 安装 fenics 的, 创建好虚拟环境后, 利用 conda install -c conda-forge fenics 进行安装, 但是直接提示 Pack…
阅读更多...
操作系统，计算机网络，数据库刷题笔记14

操作系统，计算机网络，数据库刷题笔记14

操作系统&#xff0c;计算机网络&#xff0c;数据库刷题笔记14 2022找工作是学历、能力和运气的超强结合体&#xff0c;遇到寒冬&#xff0c;大厂不招人&#xff0c;可能很多算法学生都得去找开发&#xff0c;测开 测开的话&#xff0c;你就得学数据库&#xff0c;sql&#xf…
阅读更多...
【OpenSourceC#】ET框架

【OpenSourceC#】ET框架

1. 前言 ET算是我刚接触客户端时最早知道的框架&#xff0c;ET我最初眼馋的还是他的双端功能。包揽前后端的功能&#xff0c;这个很有吸引力。但是那时候对我来说这框架太复杂了&#xff0c;没法看。 这两天又来看看&#xff0c;曾经很多不懂的地方现在都能看懂了&#xff0c…
阅读更多...
数据库拆分5--使用sharding-jdbc来实现水平拆分

数据库拆分5--使用sharding-jdbc来实现水平拆分

有三张表 user log order表&#xff0c;先将user log 和order垂直分库&#xff0c;然后将user表水平拆分 配置文件 spring.shardingsphere.enabledtruespring.shardingsphere.datasource.nameswim-user,wim-orderspring.shardingsphere.datasource.wim-user.typecom.alibaba.…
阅读更多...
【JavaEE】多线程之Thread类

【JavaEE】多线程之Thread类

一、Thread类常见方法与字段 1、构造方法 构造方法说明Thread()不带参数的构造方法Thread(String name)可以在构造时传入线程的名字Thread(Runnable run)传入Runnable&#xff0c;是创建线程的方法之一Thread(Runnable run,String name)传入线程工作并给线程起名 2、常见属性…
阅读更多...
JaveWeb框架（一）：Web入门，Http的请求和响应，https介绍，Web实战自定义服务器

JaveWeb框架（一）：Web入门，Http的请求和响应，https介绍，Web实战自定义服务器

Servlet入门 MVC实战项目 仓储管理系统JavaWeb入门介绍Http协议Http请求数据格式Http响应数据格式Web实战Demo&#xff1a;自定义服务器对比Https协议总结Redis章节复习已经过去&#xff0c;新的章节JavaWeb开始了&#xff0c;这个章节中将会回顾JavaWeb实战项目 仓储管理 代码…
阅读更多...
机器人开发--电机中的电流环、速度环、位置环

机器人开发--电机中的电流环、速度环、位置环

机器人开发--电机中的电流环、速度环、位置环电流环、速度环、位置环1 三环原理1.1 电流环1.2 速度环1.3 位置环2 各环与PID控制2.1 电流环重点在 PID&#xff08;比例、积分和微分&#xff09;2.2 速度环重点在 PI&#xff08;比例和积分&#xff09;2.3 位置环重点在 P&#…
阅读更多...
基于JAVA的企业部门报销管理信息系统的设计与实现

基于JAVA的企业部门报销管理信息系统的设计与实现

开发工具(eclipse/idea/vscode等)&#xff1a; 数据库(sqlite/mysql/sqlserver等)&#xff1a; 功能模块(请用文字描述&#xff0c;至少200字)&#xff1a; 系统部分主要分为以下几个模块&#xff1a;公告类型&#xff0c;公告信息&#xff0c;部门信息&#xff0c;员工信 息&a…
阅读更多...
手写Spring9（实现FactoryBean、对象作用域）

手写Spring9（实现FactoryBean、对象作用域）

文章目录前言目标设计项目结构一、实现1、Bean的作用范围定义和xml解析2、创建和修改对象时候判断单例和原型模式3、定义 FactoryBean 接口4、实现一个 FactoryBean 注册服务5、扩展 AbstractBeanFactory 创建对象逻辑二、测试1、事先准备2、定义 FactoryBean 对象3、配置文件4…
阅读更多...
Win32多线程调用gdal库接口

Win32多线程调用gdal库接口

作者：朱金灿 来源：clever101的专栏 为什么大多数人学不会人工智能编程？>>> 效果图和程序说明 效果图如下：   这个程序是基于MFC的GUI程序，用于给指定的文件夹批量创建金字塔。   效果图如下：   这个程序是基于Win32 API的GUI程序，用于给指定的文件创…
阅读更多...
期末前端web大作业——动漫客栈响应式bootstarp(7页) 排版整洁，内容丰富，主题鲜明

期末前端web大作业——动漫客栈响应式bootstarp(7页) 排版整洁，内容丰富，主题鲜明

HTML实例网页代码, 本实例适合于初学HTML的同学。该实例里面有设置了css的样式设置&#xff0c;有div的样式格局&#xff0c;这个实例比较全面&#xff0c;有助于同学的学习,本文将介绍如何通过从头开始设计个人网站并将其转换为代码的过程来实践设计。 ⚽精彩专栏推荐&#x1…
阅读更多...
R语言用线性回归模型预测空气质量臭氧数据

R语言用线性回归模型预测空气质量臭氧数据

尽管线性模型是最简单的机器学习技术之一&#xff0c;但它们仍然是进行预测的强大工具。 最近我们被客户要求撰写关于线性回归模型的研究报告&#xff0c;包括一些图形和统计输出。 这尤其是由于线性模型特别容易解释这一事实。在这里&#xff0c;我将讨论使用空气质量数据集…
阅读更多...
Python学习基础笔记五十四——多继承

Python学习基础笔记五十四——多继承

多继承中&#xff0c;我们子类对象调用的一个方法&#xff0c;默认是就近原则&#xff0c;找的顺序是什么&#xff1f; 在经典类中&#xff0c;是深度优先&#xff1b; 在新式类中&#xff0c;是广度优先&#xff1b; Python2.7是经典类和新式类共存&#xff0c;新式类要继承…
阅读更多...
领域模型设计模式

领域模型设计模式

前言&#xff1a; 领域是一个组织所做的事情以及其包含的一切&#xff0c;通俗地说&#xff0c;就是组织的业务范围和做事情的方式&#xff0c;也是软件开发的目标范围。比如说淘宝的电商业务&#xff0c;C2C就是电子商务的领域&#xff0c;领域驱动设计就是从领域出发&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023