【C++初阶】十一、STL---priority_queue（总）

news2024/12/23 13:53:02

目录

一、priority_queue介绍

二、priority_queue使用

三、仿函数

四、priority_queue模拟实现

4.1 版本1

4.2 版本2

一、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 来自动完成此操作
 

template <class T, class Container = vector<T>,
  class Compare = less<typename Container::value_type> > class priority_queue;

         优先级队列 priority_queue 默认使用的适配器是 vector（class Container = vector<T>），第三个模板参数是仿函数（class Compare = less<typename Container::value_type> ），仿函数下面解释

        使用 priority_queue 要包含头文件 <queue>，与 queue 的头文件一致

#include <queue>

注：priority_queue 的结构就是堆，即二叉树

二、priority_queue使用

成员函数介绍：

接口简单介绍，C++11先不介绍，后面再学

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

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

注意：默认情况下 priority_queue 是大堆（即降序）

        优先级队列默认大的优先级高，传的是 less 仿函数，底层是一个大堆；如果想控制小的优先级高，需手动传 greater 仿函数，其底层是一个小堆

测试代码

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

void Test_priority_queue() 
{
    priority_queue<int> pq;

    pq.push(3);
    pq.push(6);
    pq.push(5);
    pq.push(1);
    pq.push(6);
    pq.push(8);

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

int main()
{
    Test_priority_queue();
    return 0;
}

 运行结果，降序

如果要改成小堆（即升序），需要手动传第三个参数 greater ，使用 greater 需要包含头文件 <functional>

#include <functional>  // greater的头文件

要传第三个模板参数，就必须传第二个模板参数，这是使用缺省参的语法规定

priority_queue<int, greater<int>> pq; //error

 正确使用如下

priority_queue<int, vector<int>, greater<int> > pq;
#include <iostream>
#include <queue>
#include <functional>
using namespace std;

void Test_priority_queue()
{
    priority_queue<int, vector<int>, greater<int> > pq;

    pq.push(3);
    pq.push(6);
    pq.push(5);
    pq.push(1);
    pq.push(6);
    pq.push(8);

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

int main()
{
    Test_priority_queue();
    return 0;
}

运行结果，升序

三、仿函数

仿函数是 STL 的六大组件之一

        仿函数：使一个类的使用看上去像一个函数，该类定义出来的对象称为函数对象

        仿函数的实现就是在类中重载 () 操作符，使得该类具备类似函数的行为，就是一个仿函数 

测试，创建一个仿函数

namespace fy
{
    class less
    {
    public:
        bool operator()(int x, int y)
        {
            return x < y;
        }
    };
}

void Test()
{
    fy::less lessCompare;
    cout << lessCompare(10, 20) << endl;
}

 运行结果

仿函数支持泛型

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

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

void Test()
{
    fy::less<int> lessCompare;
    cout << lessCompare(10, 20) << endl;

    fy::greater<double> greaterCompare;
    cout << greaterCompare(10.0, 20.0) << endl;
}

 运行结果

这就是仿函数，实际上仿函数调用的只是重载的 operator() 而已

为什么要有仿函数？为了替代 C语言中的函数指针，使用代码更直观，函数指针使用起来头大，难理解！！

void( * set_malloc_handler(void (*f)()))() //这是函数指针.......

 所以，仿函数的出现就是为了替代 C语言的函数指针

四、priority_queue模拟实现

        优先级队列的模拟实现也是很简单，因为它是容器适配器，可以使用已有的生成我们想要的 

4.1 版本1

        这里要注意的向上调整和向下调整的写法，数据结构已经学过，就不废话了。这个版本的缺陷是不能很好的支持升序和降序，只能是其中的一种，使用改升序或降序就必须修改源代码，修改后也是两者不能兼并，极其不好，版本2 则是使用仿函数，可以使两者可以同时兼并

priority_queue.h

#pragma once

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

namespace fy //防止命名冲突
{
	//优先级队列模拟实现
	template<class T, class Container = vector<T>>
	class priority_queue
	{
	public:
		priority_queue(){}
        //迭代器区间构造
		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			:_con(first, last)
		{
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; --i)
			{
				adjust_down(i);
			}
		}
		//堆的向上调整
		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (_con[parent] < _con[child])
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else//已经成堆
				{
					break;
				}
			}
		}
		//队尾插入元素
		void push(const T& x)
		{
			_con.push_back(x);

			adjust_up(_con.size() - 1);
		}
		//堆的向下调整
		void adjust_down(size_t parent)
		{
			size_t child = parent * 2 + 1;

			while (child < _con.size())
			{
				if (child + 1 < _con.size() && _con[child] < _con[child + 1])
				{
					child++;
				}

				if (_con[parent] < _con[child])
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else//已经成堆
				{
					break;
				}
			}
		}
		//弹出堆顶元素
		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();

			adjust_down(0);
		}
		//获取堆顶元素
		const T& top()const
		{
			return _con[0];
		}

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

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

	private:
		Container _con;
	};
}

Test.cpp

#include "PriorityQueue.h"

void Test_priority_queue()
{
	fy::priority_queue<int> pq;
	pq.push(5);
	pq.push(1);
	pq.push(9);
	pq.push(6);
	pq.push(3);
	pq.push(3);

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

int main()
{
	Test_priority_queue();
	return 0;
}

运行结果

4.2 版本2

priority_queue.h

#pragma once

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

namespace fy //防止命名冲突
{
	//比较方式 < --- 使其结构形成大堆
	template<class T>
	class less
	{
	public:
		bool operator()(const T& x, const T& y) const
		{
			return x < y;
		}
	};
	//比较方式 > --- 使其结构形成小堆
	template<class T>
	class greater
	{
	public:
		bool operator()(const T& x, const T& y) const
		{
			return x > y;
		}
	};
	//优先级队列模拟实现
	template<class T, class Container = vector<T>, class Compare = less<T> >
	class priority_queue
	{
	public:
		priority_queue(){}
		//迭代器区间构造
		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			:_con(first, last)
		{
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; --i)
			{
				adjust_down(i);
			}
		}
		//堆的向上调整
		void adjust_up(size_t child)
		{
			Compare com;
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				//if (_con[parent] < _con[child])
				if (com(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else//已经成堆
				{
					break;
				}
			}
		}
		//队尾插入元素
		void push(const T& x)
		{
			_con.push_back(x);

			adjust_up(_con.size() - 1);
		}
		//堆的向下调整
		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[parent] < _con[child])
				if (com(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else//已经成堆
				{
					break;
				}
			}
		}
		//弹出堆顶元素
		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();

			adjust_down(0);
		}
		//获取堆顶元素
		const T& top()const
		{
			return _con[0];
		}

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

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

	private:
		Container _con;
	};
}

Test.cpp

#include "PriorityQueue.h"

void Test_priority_queue()
{
	//默认是大堆 less
	fy::priority_queue<int> pq;
	pq.push(5);
	pq.push(1);
	pq.push(9);
	pq.push(6);
	pq.push(3);
	pq.push(3);

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

	int arr[] = { 5,1,9,6,3,3 };
	//默认是大堆 less
	fy::priority_queue<int> pq2(arr, arr+6);
	while (!pq2.empty())
	{
		cout << pq2.top() << " ";
		pq2.pop();
	}
	cout << endl;

	//小堆, greater
	fy::priority_queue<int, vector<int>, greater<int> > pq3(arr, arr + 6);
	while (!pq3.empty())
	{
		cout << pq3.top() << " ";
		pq3.pop();
	}
	cout << endl;
}

int main()
{
	Test_priority_queue();
	return 0;
}

运行结果

#include "PriorityQueue.h"

void Test_priority_queue()
{
	//默认是大堆 less
	fy::priority_queue<int> pq;
	pq.push(5);
	pq.push(1);
	pq.push(9);
	pq.push(6);
	pq.push(3);
	pq.push(3);

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

	int arr[] = { 5,1,9,6,3,3 };
	//默认是大堆 less
	fy::priority_queue<int> pq2(arr, arr+6);
	while (!pq2.empty())
	{
		cout << pq2.top() << " ";
		pq2.pop();
	}
	cout << endl;

	//小堆, greater
	fy::priority_queue<int, vector<int>, greater<int> > pq3(arr, arr + 6);
	while (!pq3.empty())
	{
		cout << pq3.top() << " ";
		pq3.pop();
	}
	cout << endl;
}

int main()
{
	Test_priority_queue();
	return 0;
}

----------------我是分割线---------------

文章到这里就结束了，下一篇即将更新

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

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

相关文章

微服务网关（五）grpc代理模块

微服务网关（五）grpc代理模块

微服务网关&#xff08;五&#xff09;grpc代理模块 GRPC是谷歌出品的一个高性能、开源、通用的RPC框架&#xff0c;基于HTTP/2标准设计&#xff0c;支持普通RPC也支持双向流式传递&#xff0c;相对于thrift连接&#xff0c;它可以多路复用&#xff0c;可传递header头数据 在…
阅读更多...
Ubuntu20.04 安装Azure Kinect Sensor

Ubuntu20.04 安装Azure Kinect Sensor

本文主要记录Ubuntu20.04 安装Azure Kinect Sensor SDKAzure Kinect 人体跟踪 SDK官网&#xff1a;https://learn.microsoft.com/zh-cn/azure/Kinect-dk/body-sdk-downloadLinux版本目前只支持18.04和20.04Azure Kinect 传感器 SDK 官网&#xff1a;https://learn.microsoft.co…
阅读更多...
ubuntu20.04下配置深度学习环境GPU

ubuntu20.04下配置深度学习环境GPU

卸载子系统 C:\Users\thzn>wsl --list 适用于 Linux 的 Windows 子系统分发版: docker-desktop (默认) docker-desktop-data Ubuntu-18.04 Ubuntu-22.04 Ubuntu-20.04 C:\Users\thzn>wsl --unregister Ubuntu-18.04 ubuntu 换源 https://www.cnblogs.com/Horizon-asd/p…
阅读更多...
【编程基础之Python】4、安装Python开发工具

【编程基础之Python】4、安装Python开发工具

【编程基础之Python】4、安装Python开发工具安装Python开发工具为什么需要开发工具Anaconda自带的开发工具PyCharm安装PyCharm运行PyCharm并创建项目总结安装Python开发工具 为什么需要开发工具 通常情况下&#xff0c;为了提高开发效率&#xff0c;需要使用相应的开发工具&a…
阅读更多...
Three.js 无限平面快速教程【Plane】

Three.js 无限平面快速教程【Plane】

Three.js 提供了 Plane 概念来表示在 3d 空间中无限延伸的二维表面。 这对于光标交互很有用&#xff0c;因此你可能需要了解如何设置此平面、将其可视化并根据需要进行调整。 推荐&#xff1a;使用 NSDT场景设计器 快速搭建 3D场景。 Three.js 的 Plane 文档很好而且准确&…
阅读更多...
Locust初次体验【解决webUI没数据】

Locust初次体验【解决webUI没数据】

官方文档&#xff1a;What is Locust? — Locust 2.14.2 documentation webUI模式跑起来没有数据。。。。&#xff1f;&#xff1f;&#xff1f;&#xff1b; E:\T_Work\other\WB_Locust\my_locustfiles>locust [2023-02-14 09:57:44,530] PC-20190108TSZQ/INFO/locust.m…
阅读更多...
Java 基础面试题——基本数据类型与包装类

Java 基础面试题——基本数据类型与包装类

目录1.Java 有哪几种基本数据类型&#xff1f;分别对应哪些包装类&#xff1f;2.Java 中为什么要保留基本数据类型&#xff1f;为什么要使用包装类&#xff1f;3.基本数据类型的转换规则有哪些&#xff1f;4.基本数据类型与包装类有什么区别&#xff1f;5.什么是装箱&#xff1…
阅读更多...
MongoDB--》索引的了解及具体操作

MongoDB--》索引的了解及具体操作

目录 索引—index 索引的类型 索引的管理操作 索引的使用 索引—index 使用索引的原因&#xff1a;索引支持在MongoDB中高效地执行查询。如果没有索引&#xff0c;MongoDB必须执行全集合扫描&#xff0c;即扫描集合中的每个文档&#xff0c;以选择与查询语句匹配的文档。这…
阅读更多...
基于android的即时通讯APP 聊天APP

基于android的即时通讯APP 聊天APP

基于android的即时通讯APP 或者 聊天APP 一 项目概述 该项目是基于Android 的聊天APP系统&#xff0c;该APP包含前台&#xff0c;后台管理系统&#xff0c;前台包含用户通讯录,用户详情&#xff0c;用户聊天服务&#xff0c;用户二维码,发现功能,发现详情 , 个人中心, 个人信…
阅读更多...
【RSTP的原理和配置】

【RSTP的原理和配置】

一、RSTP 概述 RSTP使用了IEEE 802.1W协议&#xff0c;视为STP的改进版本&#xff0c;收敛速度快&#xff0c;兼容STP。 RSTP可以兼容STP&#xff0c;但是会丧失快速收敛等优势&#xff1b; 1、RSTP对STP的改进&#xff1b; 1.1、端口角色的增补、简化了生成树协议的理解及部…
阅读更多...
【基于transform和CNN的多级蒸馏:超分】

【基于transform和CNN的多级蒸馏:超分】

A hybrid of transformer and CNN for efficient single image super-resolution via multi-level distillation &#xff08;基于transform和CNN的多级蒸馏单幅图像超分辨率算法&#xff09; 近年来&#xff0c;基于卷积神经网络&#xff08;CNN&#xff09;的单幅图像超分辨…
阅读更多...
Boost库的编译

Boost库的编译

废话就不多说了&#xff0c;直接上boost编译的方法。 1、下载boost库源码 https://github.com/missionlove/boost 2、使用vs命令行工具&#xff0c;选择对应的Command工具 3、切换目录到Boost源码 bootstrap.bat 文件所在的目录下 4、运行bootstrap.bat 脚本 start bootst…
阅读更多...
CSS单位之vw、vh、vmin、vmax、%

CSS单位之vw、vh、vmin、vmax、%

CSS单位之vw、vh、vmin、vmax、% vm/vh&#xff1a;相对于视窗&#xff08;Viewport&#xff09;的高度和宽度。 1vh 等于1/100的视窗高度&#xff0c;1vw 等于1/100的视窗宽度。 视窗(Viewport)是指浏览器内部的可视区域大小&#xff0c;即window.innerWidth/window.innerHei…
阅读更多...
研报精选230213

研报精选230213

目录 【行业230213西南证券】医疗创新器械-内窥镜行业专题&#xff1a;核心三问&#xff0c;内窥镜技术趋势图谱和投资机会【行业230213国金证券】基础化工行业研究&#xff1a;成长接力&#xff0c;继续看好有边际变化的新材料【行业230213民生证券】有色金属周报&#xff1a;…
阅读更多...
Hazel游戏引擎（004）

Hazel游戏引擎（004）

本人菜鸟&#xff0c;文中若有代码、术语等错误&#xff0c;欢迎指正 我写的项目地址&#xff1a;https://github.com/liujianjie/GameEngineLightWeight&#xff08;中文的注释适合中国人的你&#xff09; 文章目录前言操作步骤讲解GitHubHazel项目此项目定位项目属性修改Sand…
阅读更多...
【蓝桥集训】第一天——前缀和

【蓝桥集训】第一天——前缀和

作者&#xff1a;指针不指南吗 专栏&#xff1a;Acwing 蓝桥集训每日一题 &#x1f43e;输出的时候&#xff0c;注意数据类型&#x1f43e; 文章目录1.截断数组2.前缀和3.子矩阵的和4.k倍区间1.截断数组 给定一个长度为 n 的数组 a1a_1a1​,a2a_2a2​,…,ana_nan​。 现在&…
阅读更多...
Windows提权流程及手法

Windows提权流程及手法

Windows提权一、信息收集二、WinSystemHelper三、Sherlock四、MSF提权五、参考链接一、信息收集 收集本机systeminfo中补丁信息 在提权辅助平台 https://i.hacking8.com/tiquan/ 中查询可利用exp 查询exp&#xff0c;选择对应的Exp下载运行 https://i.hacking8.com/ https:/…
阅读更多...
在google设置静态页面 CDN加速

在google设置静态页面 CDN加速

一、 创建bucket&#xff0c;设置bucket 链接&#xff1a;https://console.cloud.google.com/storage/browser 创建bucket 设置bucket公开访问 在bucket列表中&#xff0c;进入刚创建的bucket。 选择页面顶部附近的权限标签。 在权限部分中&#xff0c;点击 person_add 授…
阅读更多...
Linux操作系统学习（了解环境变量）

Linux操作系统学习（了解环境变量）

文章目录环境变量初识除了上述介绍的PATH&#xff0c;还有一些常见的环境变量如&#xff1a;查看环境变量方法 &#xff1a;环境变量的基本概念&#xff1a;本地变量&#xff1a;环境变量初识 环境变量解释起来比较抽象&#xff0c;先看示例&#xff1a; #include <stdio.…
阅读更多...
如果你是O型血的准妈妈，新生儿溶血症一定要提前了解，有备无患

如果你是O型血的准妈妈，新生儿溶血症一定要提前了解，有备无患

婚姻&#xff0c;最重要的是同理心&#xff0c;合适的家庭&#xff0c;但一个刚刚分娩的宝贝妈妈认为&#xff0c;爱也可能需要血型匹配。原因是宝马刚出生的宝宝在医院治疗黄疸&#xff0c;因为宝马是O型血&#xff0c;而丈夫不是O型血&#xff0c;医院治疗黄疸的宝宝很多。这…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023