【C++】STL——priority_queue的介绍和使用及模拟实现

news2024/11/23 13:15:22

priority_queue的介绍和使用及模拟实现

在这里插入图片描述

文章目录

  • priority_queue的介绍和使用及模拟实现
  • 1.priority_queue的介绍和使用
    • priority_queue的介绍
    • priority_queue的使用
  • 2. 仿函数
  • 3.堆的调整算法
    • 堆的向上调整算法
    • 堆的向下调整算法
  • 4.priority_queue的模拟实现

1.priority_queue的介绍和使用

priority_queue的介绍

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

2、其底层类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

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

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

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

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

6、需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

priority_queue的使用

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

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

使用vector作为底层容器，内部构造大堆结构

priority_queue<int, vector<int>, less<int>> q1;

使用vector作为底层容器，内部构造小堆结构

priority_queue<int, vector<int>, greater<int>> q2;

不指定底层容器和内部需要构造的堆结构。（编译器默认大堆处理）

priority_queue<int> pq;
  • 测试如下：
void test_priority_queue()
{
	// 默认是大的优先级高 ——> 默认给的仿函数为less
	priority_queue<int> pq;
	// 控制小的优先级高 ——> 给一个greater的仿函数
	//priority_queue<int, vector<int>, greater<int>> pq;
	pq.push(3);
	pq.push(1);
	pq.push(7);
	pq.push(9);
	pq.push(3);

	while (!pq.empty())
	{
		cout << pq.top() << " "; // 1 3 3 7 9
		pq.pop();
	}
}

优先级队列默认大的优先级高，传的是less仿函数，底层是一个大堆，想控制小的优先级高，传greater仿函数，底层是一个小堆。

2. 仿函数

概念：

仿函数（Functor）又称为函数对象（Function Object）是一个能行使函数功能的类。

仿函数的语法几乎和我们普通的函数调用一样，不过作为仿函数的类，都必须重载 operator() 运算符。因为调用仿函数，实际上就是通过类对象调用重载后的 operator() 运算符。

如果编程者要将某种“操作”当做算法的参数，一般有两种方法：

（1）一个办法就是先将该“操作”设计为一个函数，再将函数指针当做算法的一个参数。

（2）将该“操作”设计为一个仿函数（就语言层面而言是个 class），再以该仿函数产生一个对象，并以此对象作为算法的一个参数。很明显第二种方法会更优秀，因为第一种方法扩展性较差，当函数参数有所变化，则无法兼容旧的代码，在我们写代码时有时会发现有些功能代码，会不断地被使用。为了复用这些代码，实现为一个公共的函数是一个解决方法。不过函数用到的一些变量，可能是公共的全局变量。引入全局变量，容易出现同名冲突，不方便维护。这时就可以使用仿函数了，写一个简单类，除了维护类的基本成员函数外，只需要重载 operator() 运算符 。这样既可以免去对一些公共变量的维护，也可以使重复使用的代码独立出来，以便下次复用。而且相对于函数更优秀的性质，仿函数还可以进行依赖、组合与继承等，这样有利于资源的管理。如果再配合模板技术和 Policy 编程思想，则更加威力无穷，大家可以慢慢体会。Policy 表述了泛型函数和泛型类的一些可配置行为（通常都具有被经常使用的缺省值）。STL 中也大量涉及到仿函数，有时仿函数的使用是为了函数拥有类的性质，以达到安全传递函数指针、依据函数生成对象、甚至是让函数之间有继承关系、对函数进行运算和操作的效果。比如 STL 中的容器 set 就使用了仿函数 less ，而 less 继承的binary_function，就可以看作是对于一类函数的总体声明，这是函数做不到的。

如下内置类型比较大小关系：

// 仿函数 ——> 定义的对象可以像函数一样去地调用
struct Less
{
	bool operator()(int x, int y)
	{
		return x < y;
	}
};

struct Greater
{
	bool operator()(int x, int y)
	{
		return x > y;
	}
};

void test1()
{
	Less less; // Less -> 仿函数类型, less -> 仿函数对象
	cout << less(2, 3) << endl; 
	cout << less.operator()(2, 3) << endl;
	/* 这里我们会以为less是函数名或函数指针，其实并不是，但是它可以像函数一样去调用
	 * 它的本质被转换成less.operator(),它可以像函数一样去使用的对象，
	 * 这是C++为了避免使用C语言中复杂的函数指针，所以提出了仿函数 */
	// 如下同理
	Greater gt; 
	cout << gt(2, 3) << endl;
	cout << gt.operator()(2, 3) << endl;

}

加上模板，不限于整形的比较：

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;
	}
};

void test2()
{
	Less<int> less;
	cout << less(2, 3) << endl;
	cout << Less<int>()(3, 2) << endl; // 匿名对象
	cout << Less<double>()(1.1, 2.3) << endl; // 匿名对象
}

我们以之前实现过的自定义类型——日期类为例，观察仿函数的使用：

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);
private:
	int _year;
	int _month;
	int _day;
};

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

void test3()
{
	//priority_queue<Date> pq;
	priority_queue<Date, vector<Date>, greater<Date>> pq;
	pq.push(Date(2022, 12, 18));
	pq.push(Date(2023, 6, 18));
	pq.push(Date(2023, 1, 21));

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

注意：我们插入的是日期类的匿名对象，生命周期只在他所在的那一行。我们在调用仿函数时，必须重载日期类的大小比较，否则无法编译成功。内置类型的大小比较并不适用于自定义类型，所以必须重载自定义类型的大小比较。

但是如果使用的是日期类的指针，这样就无法使用我们定义的仿函数，这时候比较的是指针地址的大小，不符合我们的要求。这里我们可以自己再定义一个仿函数，支持对日期类的指针解引用。

class Date
{
	friend struct LessPDate;
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);
private:
	int _year;
	int _month;
	int _day;
};

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

struct LessPDate
{
	bool operator()(const Date* d1, const Date* d2) const
	{
		// return *d1 < *d2; 
		return (d1->_year < d2->_year) ||
			(d1->_year == d2->_year && d1->_month < d2->_month) ||
			(d1->_year == d2->_year && d1->_month == d2->_month && d1->_day < d2->_day);
	}
};

// 如果数据类型，不支持比较，或者比较的方式，不是你想要的
// 那么可以自己实现仿函数，按照自己想要的方式去比较，控制比较逻辑
void test4()
{
	priority_queue<Date*, vector<Date*>, LessPDate> pq;
	pq.push(new Date(2022, 12, 18));
	pq.push(new Date(2023, 6, 18));
	pq.push(new Date(2023, 1, 21));

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

3.堆的调整算法

堆的向上调整算法

image-20221220142827673

//向上调整算法
void adjust_up(size_t child)
{
	// Compare com; // 局部对象， 构造函数啥也不做，仿函数没有成员变量
	size_t parent = (child - 1) / 2;
	while (child > 0)
	{
		//if (_con[child] > _con[parent]) <=> if(_con[parent], _con[child])
		if(_com(_con[parent], _con[child]))
		{
			swap(_con[child], _con[parent]); // 不需要&_con[child]，引用
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

堆的向下调整算法

image-20221220142704036

//向下调整算法
void adjust_down(size_t parent)
{
	//Compare com;
	size_t child = parent * 2 + 1;
	while (child < _con.size())
	{
		// if (child + 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 (_com(_con[parent], _con[child]))
		{
			swap(_con[child], _con[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

4.priority_queue的模拟实现

上文我们已经实现好了仿函数，向上调整建堆，向下调整建堆。我们现在可以模拟实现优先级队列了。

  • 总代码如下：
namespace priority_queue_realize
{
	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>>
	template <class T, class Container = vector<T>, class Compare = Less<T>>
	class priority_queue
	{
	private:
		void adjust_up(size_t child)
		{
			// Compare com; // 局部对象， 构造函数啥也不做，仿函数没有成员变量
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[child] > _con[parent]) <=> if(_con[parent], _con[child])
				if(_com(_con[parent], _con[child]))
				{
					swap(_con[child], _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() && _con[child] < _con[child + 1])
				if (child + 1 < _con.size() && _com(_con[child], _con[child + 1]))
				{
					child++;
				}
				//if (_con[child] > _con[parent])
				if (_com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}

		}
	public:
		priority_queue()
		{}

		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			:_con(first, last)
		{
			for (int i = (_con.size() - 1 - 1) / 2; i < _con.size(); i++)
			{
				adjust_down(i);
			}
		}

		void push(const T& x)
		{
			_con.push_back(x);
			adjust_up(_con.size() - 1);
		}

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

		const T& top() const
		{
			// assert(_con.empty());
			return _con[0];
		}

		size_t size() const
		{
			return _con.size;
		}

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

	private:
		Container _con;
		Compare _com;
	};

	void test()
	{
		// 默认是大的优先级高 ——> 默认给的仿函数为less
		priority_queue<int> pq;
		// 控制小的优先级高 ——> 给一个greater的仿函数
		//priority_queue<int, vector<int>, greater<int>> pq;
		pq.push(3);
		pq.push(1);
		pq.push(7);
		pq.push(9);
		pq.push(3);

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

扩展：less、greater是C++库里面提供的。

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

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

相关文章

史上最简单易懂的TypeScript教程（更新中）

史上最简单易懂的TypeScript教程（更新中）

TypeScript欢迎观看由大型东方幻想车编写的typescript教程1. TypeScript: 类型&#xff08;1&#xff09;其他类型欢迎观看由大型东方幻想车编写的typescript教程 TypeScript介绍: TypeScript是JavaScript类型的严格超集&#xff0c;它可以编译成纯JavaScript。TypeScript可以在…
阅读更多...
基于VitePress搭建静态文档系统

基于VitePress搭建静态文档系统

文章目录前言一、快速上手二、常用配置2.1 类Vue风格首页2.2 顶部导航配置themeConfig.nav2.3 侧边栏导航设置2.3 文档中的链接跳转2.3.1 上一页与下一页2.3.2 文档中链接2.3.3 生成成员页三、进阶配置四、参考代码前言 vitePress&#xff1a;与vue press相似&#xff0c;是一…
阅读更多...
Spring中自定义事件监听

Spring中自定义事件监听

目录 一、Spring中的事件监听 二、自定义事件监听 三、例子 1、事件 2、事件监听器 3、事件发布操作 三、测试注意 一、Spring中的事件监听 当处理完一段代码逻辑&#xff0c;后面需要同时执行多个任务&#xff0c;有什么好方法呢&#xff1f;如果在微服务项目中&…
阅读更多...
【自用】VUE项目 宝塔部署 上线阿里云服务器CentOS7.6

【自用】VUE项目 宝塔部署 上线阿里云服务器CentOS7.6

一、给VUE项目打包 1.开始打包 运行命令&#xff1a; npm run build2.找到打包好的 dist 文件夹 要记住这个dist文件放在了哪儿&#xff0c;记住哦&#xff01; 二、服务器端安装宝塔面板 1.进入root用户并执行命令 yum install -y wget && wget -O install.…
阅读更多...
Node基础——认识Node

Node基础——认识Node

什么是Node 首先JavaScript是一门编程语言&#xff0c;就像Java、Python、C#、GO一样&#xff0c;在Node出来之前&#xff0c;JavaScript主要运行于浏览器中&#xff0c;用来控制页面的展示逻辑&#xff0c;以及交互操作等。JavaScript之所以能够在浏览器中执行&#xff0c;是…
阅读更多...
Docker搭建Mysql主主架构

Docker搭建Mysql主主架构

文章目录mysql主从架构原理MySQL通用架构方案搭建步骤1. docker创建俩台mysql 端口&#xff1a;23306 和 333062. 创建my.cnf&#xff0c;并将my.cnf拷贝到docker容器中&#xff0c;并重启生效3. 配置完成&#xff0c;开始执行sql&#xff0c;设置主从主主同步mysql主从架构原理…
阅读更多...
CSDN每日一练非负整数求和 C语言

CSDN每日一练非负整数求和 C语言

题目名称&#xff1a;非负整数求和 时间限制&#xff1a;1000ms 内存限制&#xff1a;256M 题目描述&#xff1a; 给定两个字符串形式的非负整数 num1 和 num2 &#xff0c;计算它们的和。 注意&#xff1a; - num1 和 num2 的长度都小于 5100. - num1 和 num2 都只包含数字 0…
阅读更多...
【圣诞节特辑】爱心代码（程序员的浪漫plus+）-李峋

【圣诞节特辑】爱心代码（程序员的浪漫plus+）-李峋

2022年圣诞节到来啦&#xff0c;很高兴这次我们又能一起度过~ 唯有热爱&#xff0c;可抵岁月漫长&#xff0c;唯有热爱&#xff0c;不畏世间无常&#xff01; 一、前言 前段时间《点燃我温暖你》中李峋的爱心代码超级火&#xff0c;看着特别心动&#xff01;这不&#xff0c;圣…
阅读更多...
贪心算法(Java版本)

贪心算法(Java版本)

一、贪心算法 1、算法描述 贪心算法&#xff08;Greedy algorithm&#xff09;&#xff0c;又叫做贪婪算法。 在对问题求解时&#xff0c;不从整体考虑&#xff0c;而是从问题的某一个初始解出发&#xff0c;每一步选择中都采取在当前状态下最好或最优的选择&#xff08;局部…
阅读更多...
vcpkg踩坑记录

vcpkg踩坑记录

接触了vcpkg一段时间, 感觉在包管理方面确实很有帮助, 然而在使用中, 也碰到了各种各样的问题, 总结记录一下. vcpkg github: https://github.com/Microsoft/vcpkg 快速使用指南 To get started: > git clone https://github.com/Microsoft/vcpkg.git(也可以从下载地址直…
阅读更多...
C语言—局部变量和全局变量

C语言—局部变量和全局变量

不同函数之间定义的变量是无法相互进行访问的&#xff1b; #include <stdio.h>void Test();int main() {int a 100;printf("%d", b); }void Test() {int b 200;printf("%d", a); } 在main函数中无法访问到Test中的变量b&#xff0c;同样&#xff…
阅读更多...
2022吴恩达机器学习课程——第三课（非监督学习）

2022吴恩达机器学习课程——第三课（非监督学习）

注&#xff1a;参考B站视频教程 视频链接&#xff1a;【(强推|双字)2022吴恩达机器学习Deeplearning.ai课程】 写在前面&#xff1a;文章只是为了记录学习课程的整个过程&#xff0c;方便以后查漏补缺&#xff0c;方便找到对应章节&#xff0c;希望看到这篇文章的同学能够认真的…
阅读更多...
Numpy+PIL实现图片的自由旋转

Numpy+PIL实现图片的自由旋转

1.内容简介 使用PIL和Numpy编程实现图片的自由旋转。 2.技术要点 &#xff08;1&#xff09;用Python PIL库将图片读取为NumPy 数组。 &#xff08;2&#xff09;采用旋转后图像幅面放大的图像旋转变换方式&#xff0c;根据旋转角度和原图像尺寸计算图像像素点的旋转变换矩阵…
阅读更多...
MySQL中 java 的 JDBC 编程使用方法及驱动包的下载和使用

MySQL中 java 的 JDBC 编程使用方法及驱动包的下载和使用

文章目录1.简介2.JDBC 的使用2.1 先安装对应数据库的驱动包~~2.2 把安装好的 jar 驱动包导入到项目中~~2.2.1 在项目中创建目录&#xff0c;把 jar 包拷贝进来。2.2.2 右键创建的目录3.编写数据库代码插入一个记录4.查看插入记录后的数据表5.如何编写代码实现查找操作1.简介 实…
阅读更多...
数据库实验2 数据库安全性定义与检查

数据库实验2 数据库安全性定义与检查

前言&#xff1a;记得验收时问了一个问题吧&#xff0c;就是用户和角色的区别是什么 实验2.1自主存取控制实验 1.实验目的 掌握自主存取控制权限的定义和维护方法。 2.实验内容和要求 定义用户、角色,分配权限给用户、角色,回收权限,以相应的用户名登录数据库验证权限分配…
阅读更多...
分享巧记Linux命令的方法

分享巧记Linux命令的方法

最近有些学弟经常私信问我说&#xff0c;他们自己是Linux方面的小白&#xff0c;对于Linux的命令了解十分的少&#xff0c;虽然每次跟着我推荐的学习视频教程可以进行操作&#xff0c;但是离开了视频&#xff0c;就又是两眼抓瞎&#xff0c;什么也想不起来。不知道怎么样通过命…
阅读更多...
【数据结构】队列与Queue接口

【数据结构】队列与Queue接口

目录 一、队列 二、 Java里的Queue接口 1、概述 2、常用方法 1.入队 2.出队 3.获取队首元素 4、判空 三、单链表实现队列 1、准备字段 2、实现入队 3、实现出队 4、实现获取队首元素 5、实现判空 四、循环队列的实现 1、前言 2、字段准备 3、实现入队 4、实现…
阅读更多...
一致性哈希

一致性哈希

一、简介 这个算法是一种特殊的哈希算法&#xff0c;目的是解决分布式缓存的问题。 普通哈希算法在分布式存储具有较大的局限性&#xff0c;简单的讲就是难以扩展。 一致性哈希相对而言具有较好的容错性和可扩展性&#xff0c;更加适合现在的分布式存储。 二、经典哈希版本 …
阅读更多...
SpringBoot+Vue项目实践课程教学管理平台

SpringBoot+Vue项目实践课程教学管理平台

文末获取源码 开发语言&#xff1a;Java 使用框架&#xff1a;spring boot 前端技术&#xff1a;JavaScript、Vue.js 、css3 开发工具&#xff1a;IDEA/MyEclipse/Eclipse、Visual Studio Code 数据库&#xff1a;MySQL 5.7/8.0 数据库管理工具&#xff1a;phpstudy/Navicat JD…
阅读更多...
✿✿✿JavaScript --- JSON

✿✿✿JavaScript --- JSON

目录 1.JSON的简介 2.JSON的语法规则 3.JSON 字符串转换为 JavaScript 对象 4.常用的JSON相关的函数 5.JSON对象的遍历 6.补充&#xff1a;JS中的this关键字 1.JSON的简介 JSON&#xff08; JavaScript Object Notation &#xff09; 是用于存储和传输数据的格式&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023