【C++】学习笔记——优先级队列

news2025/1/12 6:21:55

文章目录

  • 十、优先级队列
    • 1. priority_queue的介绍
    • 2. 优先级队列如何使小的数据优先级高
    • 3. 仿函数介绍
    • 4. priority_queue的模拟实现
  • 补： 反向迭代器
  • 未完待续

十、优先级队列

1. priority_queue的介绍

优先级队列 其实也不属于队列，它跟 stack 和 queue 一样，都是 容器适配器 。
在这里插入图片描述
优先级队列的默认适配容器是 vector 。要使用优先级队列的话，需要包含 queue 头文件 。
在这里插入图片描述
优先级队列的接口也非常简单明了，我们来简单试一下：

#include<iostream>
// 包含 queue 头文件
#include<queue>
using namespace std;

int main()
{
	priority_queue<int> pq;
	pq.push(3);
	pq.push(1);
	pq.push(4);
	pq.push(2);

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

	return 0;
}

在这里插入图片描述
我们插入的数据是 3 1 4 2 ，打印出来的数据却是 4 3 2 1 ，竟然将其排了个降序，这有点像我们之前学过的一种数据结构啊。是的，它很像 堆，它底层其实就是 大根堆 。优先级队列 就是按优先级取数据，堆顶数据就是优先级最高的。

2. 优先级队列如何使小的数据优先级高

优先级队列默认是大根堆，大的数据优先级高，那么我们该如何使小的数据优先级高呢？就是使优先级队列以 小根堆 的形式实现。答案嘛，就涉及到 STL 的另一个组件了—— 仿函数 。
在这里插入图片描述
优先级队列 模板的第三个参数就是仿函数，默认是 less （小于），如果要使其成 小根堆 的形式，则需要将其参数修改为 greater （大于），由于缺省参数不能跳跃着传，所以需要将前面两个参数都给加上才行。

// 三个参数
priority_queue<int, vector<int>, greater<int>> pq;

我们来使用一下：

#include<iostream>
#include<queue>
using namespace std;

int main()
{
	priority_queue<int, vector<int>, greater<int>> pq;
	pq.push(3);
	pq.push(1);
	pq.push(4);
	pq.push(2);

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

	return 0;
}

在这里插入图片描述
在其他有这种仿函数的函数中，less 默认都是排升序 ，greater 都是排降序 ，比如 sort 函数 ，而 优先级队列 中，less 是大根堆 ， greater 是小根堆 。

// sort 排降序
sort(v.begin(), v.end(), greater<int>());

注意，sort 函数 的第三个参数是函数参数，需要传对象，所以末尾带着 () 来创建匿名对象，而 优先级队列 则是类模板，传类型，不需要带 () 。

3. 仿函数介绍

仿函数其实是一个类型 ，一种结构。

struct Less
{
	// 重载 ()
	bool operator()(const int& x, const int& y)
	{
		return x < y;
	}
};

我们要怎样使用这个类呢？

int main()
{
	Less Lessfunc;

	cout << Lessfunc(1, 2) << endl;
	// 上面写法本质上是下面写法
	cout << Lessfunc.operator()(1, 2) << endl;

	return 0;
}

在这里插入图片描述
大家有没有发现，上面的写法 很像函数 啊，Lessfunc 就像函数名一样，但是没想到其实他是对象名。所以 仿函数就是对象很像函数的类型 。把模板套上就可以使类型泛型。

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

所以在 sort 函数 里的第三个参数，greate< int >() 就是一个匿名对象，类型是 int ，调用重载 () 符号。

4. priority_queue的模拟实现

先把简单的框架搭好，再来挨个实现。由于 STL库 里的 priority_queue 是位于 queue 头文件里，所以我们这里头文件取名为 Queue.h 。

// Queue.h
#pragma once

namespace my
{
	template<class T, class Container = vector<T>>
	class priority_queue
	{
	public:
		void push(const T& x)
		{

		}

		void pop()
		{

		}

		bool empty()
		{

		}

		size_t size()
		{

		}

		const T& top()
		{

		}
	private:
		Container _con;
	};
}

我们来想一想，我们的堆是如何插入数据的：堆是尾部插入数据，然后向上调整位置 。那堆是如何删除数据的呢？堆是收尾交换数据，然后尾删，最后将堆顶数据向下调整 。

#pragma once

namespace my
{
	template<class T, class Container = vector<T>>
	class priority_queue
	{
	public:

		adjust_up(size_t child)
		{

		}

		adjust_down(size_t parent)
		{

		}

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

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

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

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

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

向上调整函数注意的就是什么情况可以向上调整，当孩子的值比父亲大时，需要将孩子的位置与父亲的位置进行交换 ，然后更新孩子和父亲的下标。那什么时候结束调整呢？当孩子的值比不父亲的值大，或者孩子已经到堆顶位置 此时需要结束调整。

adjust_up(size_t child)
{
	size_t parent = (child - 1) / 2;
	while (child > 0)
	{
		if (_con[child] > _con[parent])
		{
			// 交换数据
			std::swap(_con[child], _con[parent]);
			// 更新下标
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{ 
			break;
		}
	}
}

向下调整需要注意的是，父节点要是最大的值，所以要交换也是与最大的孩子交换，第一步需要找到最大的孩子 ，然后 判断父亲是否比孩子小，小则交换，最后判断结束条件 父节点已经不再比最大的孩子小或者，已经到达叶子节点 则退出。

adjust_down(size_t parent)
{
	size_t child = parent * 2 + 1;
	// 左孩子孩子存在
	while (child < _con.size())
	{
		// 右孩子存在且比左孩子大
		if (child + 1 < _con.size() && _con[child + 1] > _con[child])
		{
			++child;
		}

		if (_con[parent] < _con[child])
		{
			// 交换
			std::swap(_con[parent], _con[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

除了仿函数外，我们的代码已经实现到了：

// Queue.h
#pragma once
#include<vector>
namespace my
{
	template<class T, class Container = vector<T>>
	class priority_queue
	{
	public:

		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (_con[child] > _con[parent])
				{
					std::swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{ 
					break;
				}
			}
		}

		void adjust_down(size_t parent)
		{
			size_t child = parent * 2 + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				{
					++child;
				}

				if (_con[parent] < _con[child])
				{
					std::swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

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

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

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

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

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

// test.cpp
#include<iostream>
#include"Queue.h"
using namespace std;

int main()
{
	my::priority_queue<int> pq;
	pq.push(1);
	pq.push(3);
	pq.push(4);
	pq.push(2);

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

	return 0;
}

在这里插入图片描述
OK，这里默认大堆就已经完成了。但是我们这个代码并不能控制变成小堆，我们需要 使用仿函数来控制比较逻辑 。

// 在 my 命名空间内
template<class T>
class less
{
public:
	bool operator()(const T& x, const T& y)
	{
		return x < y;
	}
};

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

有了仿函数，所以我们的优先级队列模板参数就要将其加上。

// 默认大根堆，第三个参数默认是仿函数 less
template<class T, class Container = vector<T>, class Compare = less<T>>
class priority_queue
{
public:
	//
private:
	//
};

所以，类里的比较大小的判断就可以使用仿函数来调用对象来实现。

void adjust_up(size_t child)
{
	// 这里
	Compare com;
	size_t parent = (child - 1) / 2;
	while (child > 0)
	{
		// _con[parent] < _con[chlid]
		if (com(_con[parent], _con[child]))
		{
			std::swap(_con[child], _con[parent]);
			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())
	{
		// _con[child] < _con[child + 1]
		if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
		{
			++child;
		}

		//_con[parent] < _con[child]
		if (com(_con[parent], _con[child]))
		{
			std::swap(_con[parent], _con[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

测试一下：

#include<iostream>
#include"Queue.h"
using namespace std;

int main()
{
	// 大堆
	my::priority_queue<int> pq;
	pq.push(1);
	pq.push(3);
	pq.push(4);
	pq.push(2);

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

	// 小堆
	my::priority_queue<int, vector<int>, greater<int>> pq2;
	pq2.push(1);
	pq2.push(3);
	pq2.push(4);
	pq2.push(2);

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

	return 0;
}

在这里插入图片描述

可以。

补： 反向迭代器

反向迭代器其实可以通过修改正向迭代器来达到目的，但是我们要求代码复用，所以需要用另一种方法来实现反向迭代器。此时我们可以使用 迭代器适配器 来实现所有容器的反向迭代器。你给我一个容器的正向迭代器，我来帮你实现其反向迭代器。

反向迭代器和正向迭代器的不同点在哪？功能类似，++和–方向不一样 。
其中反向迭代器的模板部分代码就如下所示，只需要注意反向迭代器要正确调用正向迭代器的函数就能成功实现。比如：++调用–，–调用++。

#pragma once
namespace me
{
	template<class Iterator, class Ref, class Ptr>
	class ReverseIterator
	{
	public:
		typedef ReverseIterator<Iterator, Ref, Ptr> Self;

		Iterator _it;
		
		ReverseIterator(Iterator it)
			:_it(it)
		{}

		Ref operator*()
		{
			Iterator tmp = _it;
			return *(--tmp);
		}

		Ptr operator->()
		{
			return &(operator*());
		}

		// 前置++
		Self& operator++()
		{
			--_it;
			return *this;
		}

		// 前置--
		Self& operator--()
		{
			++_it;
			return *this;
		}

		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}
	};
}

未完待续

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

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

相关文章

[Linux_IMX6ULL驱动开发]-GPIO子系统和Pinctrl子系统

[Linux_IMX6ULL驱动开发]-GPIO子系统和Pinctrl子系统

目录 Pinctrl子系统的概念 GPIO子系统的概念 定义自己的GPIO节点 GPIO子系统的函数 引脚号的确定 基于GPIO子系统的驱动程序 驱动程序 设备树修改 之前我们进行驱动开发的时候&#xff0c;对于硬件的操作是依赖于ioremap对寄存器的物理地址进行映射&#xff0c;以此来达…
阅读更多...
SpringBoot实现统一返回值+全局异常处理

SpringBoot实现统一返回值+全局异常处理

在这里首先感谢的就是程序员老罗&#xff0c;从他的项目里面学到了这些东西。 首先就是去创建一个SpringBoot项目&#xff0c;这里我就不多做赘述了 封装一个统一返回对象 package com.example.demo.vo;public class ResponseVO<T> {private String status;private In…
阅读更多...
数据驱动实战二

数据驱动实战二

目标 掌握数据驱动的开发流程掌握如何读取JSON数据文件巩固PO模式 1. 案例 对TPshop网站的登录模块进行单元测试 1.1 实现步骤 编写测试用例采用PO模式的分层思想对页面进行封装编写测试脚本定义数据文件&#xff0c;实现参数化 1.2 用例设计 1.3 数据文件 {"login…
阅读更多...
JVM调优—减少FullGC

JVM调优—减少FullGC

背景 最近负责了一个审批流程新项目&#xff0c;带领了几个小伙伴&#xff0c;哼哧哼哧的干了3个月左右&#xff0c;终于在三月底完美上线了&#xff0c;好消息是线上客户用的很丝滑&#xff0c;除了几个非常规的业务提单之外&#xff0c;几乎没有什么大的问题&#xff0c;但是…
阅读更多...
4D 成像毫米波雷达：新型传感器助力自动驾驶

4D 成像毫米波雷达：新型传感器助力自动驾驶

1 感知是自动驾驶的首要环节&#xff0c;高性能传感器必不可少 感知环节负责对侦测、识别、跟踪目标&#xff0c;是自动驾驶实现的第一步。自动驾驶的实现&#xff0c;首先要能够准确理解驾驶环境信息&#xff0c;需要对交通主体、交通信号、环境物体等信息进行有效捕捉&#x…
阅读更多...
【静态分析】软件分析课程实验A4-类层次结构分析与过程间常量传播

【静态分析】软件分析课程实验A4-类层次结构分析与过程间常量传播

官网&#xff1a;作业 4&#xff1a;类层次结构分析与过程间常量传播 | Tai-e 参考&#xff1a;https://www.cnblogs.com/gonghr/p/17984124 ----------------------------------------------------------------------- 1 作业导览 为 Java 实现一个类层次结构分析&#xf…
阅读更多...
249 基于matlab的MED、OMEDA、MOMEDA、MCKD信号处理方法

249 基于matlab的MED、OMEDA、MOMEDA、MCKD信号处理方法

基于matlab的MED、OMEDA、MOMEDA、MCKD信号处理方法。最小熵反褶积(MED)&#xff0c;最优最小熵反卷积调整卷积 (OMEDA),多点最优最小熵解卷积调整&#xff08;Multipoint Optimal Minimum Entropy Deconvolution Adjusted&#xff0c;MOMEDA&#xff09;&#xff0c;最大相关峭…
阅读更多...
【智能优化算法】蜜獾优化算法(Honey Badger Algorithm,HBA)

【智能优化算法】蜜獾优化算法(Honey Badger Algorithm,HBA)

蜜獾优化算法(Honey Badger Algorithm,HBA)是期刊“MATHEMATICS AND COMPUTERS IN SIMULATION”&#xff08;IF 3.6&#xff09;的2022年智能优化算法 01.引言 蜜獾优化算法(Honey Badger Algorithm,HBA)受蜜獾智能觅食行为的启发&#xff0c;从数学上发展出一种求解优化问题的…
阅读更多...
vue3实现动态表格

vue3实现动态表格

vue3结合element-plus实现动态表格&#xff0c;可添加、删除、对单行数据判断。 实现效果&#xff1a;查看源代码 实现代码&#xff1a; <div class"arrTable-Box"><el-table :data"tableData" border max-height"250"><el-t…
阅读更多...
【强训笔记】day17

【强训笔记】day17

NO.1 思路&#xff1a;用一个字符串实现&#xff0c;stoi函数可以转化为数字并且去除前导0。 代码实现&#xff1a; #include <iostream> #include<string> using namespace std;string s;int main() {cin>>s;for(int i0;i<s.size();i){if(s[i]%20) s[…
阅读更多...
大模型模型简化机器人训练；简单易用的 3D 工具Project Neo；特斯拉放出了擎天柱机器人最新训练视频

大模型模型简化机器人训练；简单易用的 3D 工具Project Neo；特斯拉放出了擎天柱机器人最新训练视频

✨ 1: DrEureka 利用大语言模型自动化将机器人仿真环境训练结果转移到真实世界 DrEureka是一种利用大型语言模型&#xff08;LLMs&#xff09;自动化和加速从仿真&#xff08;sim&#xff09;到现实世界&#xff08;real&#xff09;转移的技术。在机器人技能学习领域&#x…
阅读更多...
网络编程套接字和传输层tcp，udp协议

网络编程套接字和传输层tcp，udp协议

认识端口号 我们知道在网络数据传输的时候&#xff0c;在IP数据包头部有两个IP地址&#xff0c;分别叫做源IP地址和目的IP地址。IP地址是帮助我们在网络中确定最终发送的主机&#xff0c;但是实际上数据应该发送到主机上指定的进程上的&#xff0c;所以我们不仅要确定主机&…
阅读更多...
MultiBoot 和 QuickBoot

MultiBoot 和 QuickBoot

目录 MultiBoot简介MultiBoot 实现方式设置 bitstream 属性使用 ICAPE2 原语WBSTAR 寄存器定义 MultiBoot 工作流程生成mcs固化文件 Tcl 指令Fallback状态寄存器MultiBoot 正常加载状态看门狗1超时状态看门狗2超时状态CRC 错误和无 DESYNC 命令IDCODE 错误状态CRC 错误状态 Wat…
阅读更多...
【AMBA Bus ACE 总线 8 -- ICache maintenance】

【AMBA Bus ACE 总线 8 -- ICache maintenance】

请阅读【AMBA Bus ACE 总线与Cache 专栏 】 欢迎学习：【嵌入式开发学习必备专栏】 文章目录 ACE ICache maintenanceACE ICache maintenance 图 1-1 当一个OS run 多个cpu的时候，根据调度算法的不同，OS 可以根据调度算法的不同分别 run 在某个具体的CPU上，因此，它们会有…
阅读更多...
Linux修炼之路之初识操作系统+基础指令(1)

Linux修炼之路之初识操作系统+基础指令(1)

目录 引言 一&#xff1a;对操作系统(OS)的简单了解 1.操作系统(OS) 是什么 2.操作系统好坏的衡量标准 3.操作系统存在的重要性 4.理解所有在计算机上的操作 二&#xff1a;Linux与windows操作的特点区别 三&#xff1a;基础指令 1.ls 指令 1.使用 2.常用选项 2.…
阅读更多...
【C++语言】Date类的代码实现（操作符重载运用）

【C++语言】Date类的代码实现（操作符重载运用）

文章目录 前言Date类的构思Date类的相关实现基本框架&#xff08;默认成员函数&#xff09;计算n天前\后的日期补充&#xff1a;前置、后置说明判断两个日期的关系&#xff08;大于&#xff0c;小于等&#xff09;&#xff1b;可以计算两个日期之间相差多少天补充&#xff1a;流…
阅读更多...
rbac权限和多级请假设计的流程演示和前端页面实现

rbac权限和多级请假设计的流程演示和前端页面实现

登录账号&#xff1a;t6普通用户 t7部门经理 m8总经理 密码都为&#xff1a;test 多级请假&#xff1a;7级及以下申请请假需要部门经理审核&#xff0c;若是请假时长超过72小时&#xff0c;则需要总经理审核&#xff0c;7级申请请将需要总经理审核&#xff0c;总经理请假自动审…
阅读更多...
VBA_NZ系列工具NZ06:VBA创建PDF文件说明

VBA_NZ系列工具NZ06:VBA创建PDF文件说明

我的教程一共九套及VBA汉英手册一部&#xff0c;分为初级、中级、高级三大部分。是对VBA的系统讲解&#xff0c;从简单的入门&#xff0c;到数据库&#xff0c;到字典&#xff0c;到高级的网抓及类的应用。大家在学习的过程中可能会存在困惑&#xff0c;这么多知识点该如何组织…
阅读更多...
这3种深拷贝实现，你都知道吗？

这3种深拷贝实现，你都知道吗？

目录&#xff1a; 1、JSON.parse 2、structuredClone 3、cloneDeep
阅读更多...
Secure Transformer Inference Made Non-interactive

Secure Transformer Inference Made Non-interactive

目录 1.概述2.Attention2.1 Matrix multiplication (ciphertext-plaintext).2.2 Matrix multiplication (ciphertext-ciphertext)2.3 Placement of bootstrapping3.SIMD密文压缩和解压缩4.SIMD槽折叠5.实验结果 1.概述 我们提出了NEXUS&#xff0c;这是第一个用于安全变压器推…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023