priority_queue的使用以及模拟实现

暗恋 懒羊羊2024-04-11 23:37

前言

上一期我们对stack和queue进行了使用的介绍，以及对底层的模拟实现！以及容器适配器做了介绍，本期我们在来介绍一个容器适配器priority_queue！

本期内容介绍

priority_queue的使用

仿函数介绍

priority_queue的模拟实现

什么是priority_queue?

priority_queue称为优先级队列，实际上就是堆（如果忘了什么是堆， 请点击这里）！它也是容器适配器，底层默认的容器是vector，默认是大堆！

常用的接口介绍

empty

判断是否为空

size

元素的个数

top

获取堆顶元素

注意：堆顶元素是不允许修改的，如果修改了会影响整个堆的结构，所以用const修饰！！

push

插入一个新元素

pop

删除堆顶的元素

OK，用一下！

cpp 复制代码 
void test()
{
	priority_queue<int> pq;
	pq.push(2);
	pq.push(15);
	pq.push(-1);
	pq.push(90);

	size_t sz = pq.size();
	cout << sz << endl;

	bool empty = pq.empty();
	cout << empty << endl;

	int top = pq.top();
	cout << top << endl;

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

priority_queue在是很有用的，例如TopK问题和堆排序。堆排序不在介绍，在数据结构已经详细的介绍了，这里拿个题目来再次理解一下TopK：

数组中第K大元素

它的题目意思就是让你，找出第K大的元素，但是要求时间度杂度O(N)!

思路：这里有三种， 第三种最优。

1、利用排序数组，然后返回倒数k个元素即可！

2、借助堆

3、快速选择算法（算法专栏介绍）

我们这里就先介绍前两种！

1、利用排序数组，然后返回倒数k个元素即可！（时间复杂度不符合）

cpp 复制代码 
class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        return nums[nums.size() -k ];
    }
};

这里虽然过了，但是这个代码的时间复杂度是O(N*logN)，不符合！

2、借助堆

cpp 复制代码 
class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        priority_queue<int> pq(nums.begin(), nums.end());//将数组的元素放到堆里面
        for(int i = k; i > 1; i--)//将前k-1个弹出堆
        {
            pq.pop();
        }

        return pq.top();//返回堆顶的元素
    }
};

OK，这就过了，但是时间复杂度也是不行的！也还是O(N*logN)。最优解在后续的算法专栏会介绍！这主要是主要是演示一下堆在OJ中的用法~！

仿函数介绍

仿函数是一种类，它的对象可以向函数一样被调用。他是一种可调用对象，可以向像函数一样接收参数并返回结果！通常情况，仿函数是通过一个类实现operator ()来实现的！

例如，上面刚介绍的priority_queue:

这里的less就是一个仿函数！还有就是sort:

OK，举个仿函数的例子：

cpp 复制代码 
struct cmp
{
	bool operator()(const int& a, const int& b)
	{
		return a < b;
	}
};

//class cmp
//{
//public:
//	bool operator()(const int& a, const int& b)
//	{
//		return a < b;
//	}
//};

void test()
{
	cmp cm;
	int result1 = cm(3, 5);

	int result2 = cm.operator()(3, 5);

	int result3 = cmp()(3, 5);
}

第一种和第二种本质是同一种，第二种是第一种的显示调用，第三种是匿名对象调用！当然这里的struct可以是class但注意的是如果是class你必须吧权限设置为public！

仿函数的用途

仿函数的用途我目前碰到的有两种（后面遇见了在补充）：

1、STL算法库中的某些算法来用 仿函数定义他们的行为！例如：sort等

2、容器的自定义行为！例如priority_queue指定大小堆！等

cpp 复制代码 
#include <algorithm>
template<class T>
struct Compare
{
	bool operator() (const T& a, const T& b)
	{
		return a > b;
	}
};

void test()
{	
	vector<int> v = { 1,3,0,12,43,5,9 };
	sort(v.begin(), v.end());//默认是升序
	for (const auto& e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	sort(v.begin(), v.end(), Compare<int>());//降序  --》用匿名对象
	Compare<int> cmp;
	sort(v.begin(), v.end(), cmp);//降序 --》用实名对象
	for (const auto& e : v)
	{
		cout << e << " ";
	}
	cout << endl;
}

大堆和小堆

cpp 复制代码 
void test()
{
	vector<int> v = { 0,12,43,5,9 };
	priority_queue<int> pq1(v.begin(), v.end());//默认大堆
	while (!pq1.empty())
	{
		cout << pq1.top() << " ";
		pq1.pop();
	}
	cout << endl;

	priority_queue<int, vector<int>, greater<int>> pq2(v.begin(), v.end());//指定为小堆
	while (!pq2.empty())
	{
		cout << pq2.top() << " ";
		pq2.pop();
	}
	cout << endl;
}

这里priority_queue默认是less：

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

如果要切换为小堆，就得指定仿函数为greater,但是我们知道参数是倒着（从右往左）传递的，所以这里要指定为小堆的话，还要指定它的底层适配的容器~！一般是vector也可以是deque！！

priority_queue的模拟实现

cpp 复制代码 
priority_queue() 
{}

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

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

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

这几个不在多说，很简单直接调用默认容器的相关接口即可~！主要介绍一下这里的插入、删除和用用一段迭代器区间构造！

push

先插入到适配容器的尾部，然后进行向上调整！（向上调整不了解的点击上面介绍对那个文章的链接回忆一下）

另外注意的是这里我们不再是以前的大于小于比较了，而是用仿函数！

cpp 复制代码 
void adjust_up(size_t child)
{
	size_t parent = (child - 1) / 2;
	while (child > 0)
	{
		if (cmp()(_con[parent], _con[child]))//孩子比父亲大（小），交换
		{
			swap(_con[parent], _con[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;//否则，结束掉
		}
	}
}
cpp 复制代码 
void push(const T& val)
{
	_con.push_back(val);
	adjust_up(_con.size() - 1);
}

pop

先交换堆顶数据和最后一个数据！然后删除掉，堆顶数据，进行向下调整~！（向下调整和向上调整一样，详细见数据结构那里）

另外注意的是这里我们不再是以前的大于小于比较了，而是用仿函数！

cpp 复制代码 
void adjust_down(size_t parent)
{
	size_t child = parent * 2 + 1;//假设第一个孩子就是要交换的孩子
	while (child < _con.size())
	{
		if (child + 1 < _con.size() && cmp()(_con[child], _con[child + 1]))//假设错了
		{
			++child;//调整
		}

		if (cmp()(_con[parent], _con[child]))//孩子比父亲大（小）
		{
			swap(_con[parent], _con[child]);//交换
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;//否则，结束掉
		}
	}
}
cpp 复制代码 
void pop()
{
	swap(_con.front(), _con.back());
	_con.pop_back();
	adjust_down(0);
}

迭代器区间构造

这里其实注意的就一点，当把数据给到适配器的容器后，要保证是堆结构！所以就要建堆，建堆的方式有两种（详见数据结构那里）向上调整建堆 和 向下调整建堆！

cpp 复制代码 
template<class Iterator>
priority_queue(Iterator first, Iterator last)
	:_con(first, last)
{
	int sz = _con.size();
	//向下调整建堆 O(N)
	for (int i = (sz - 1) / 2; i >= 0; i--)
	{
		adjust_down(i);
	}

	//向下调整建堆 O(N*logN)
	//for (int i = 1; i < sz; i++)
	//{
	//	adjust_up(i);
	//}
}

全部源码

cpp 复制代码 
#pragma once

#include <vector>

namespace cp
{
	template<class T>
	struct less
	{
		bool operator()(const T& a, const T& b)
		{
			return a < b;
		}
	};

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


	template<class T, class Con = std::vector<T>, class cmp =  less<T>>
	class priority_queue
	{
	public:
		priority_queue() 
		{}

		template<class Iterator>
		priority_queue(Iterator first, Iterator last)
			:_con(first, last)
		{
			int sz = _con.size();
			//向下调整建堆 O(N)
			for (int i = (sz - 1) / 2; i >= 0; i--)
			{
				adjust_down(i);
			}

			//向下调整建堆 O(N*logN)
			//for (int i = 1; i < sz; i++)
			//{
			//	adjust_up(i);
			//}
		}

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

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

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

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

		void pop()
		{
			swap(_con.front(), _con.back());
			_con.pop_back();
			adjust_down(0);
		}

	private:
		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (cmp()(_con[parent], _con[child]))//孩子比父亲大（小），交换
				{
					swap(_con[parent], _con[child]);
					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() && cmp()(_con[child], _con[child + 1]))//假设错了
				{
					++child;//调整
				}

				if (cmp()(_con[parent], _con[child]))//孩子比父亲大（小）
				{
					swap(_con[parent], _con[child]);//交换
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;//否则，结束掉
				}
			}
		}

	private:
		Con _con;
	};
}

OK，验证一下：

OK，没有问题！本期内容就分享到这里，好兄弟我们下期再见！

结束语：无人问津的日子，更应该加倍努力！

相关推荐
van叶～41 分钟前
算法妙妙屋-------1.递归的深邃回响：二叉树的奇妙剪枝
c++·算法
knighthood20011 小时前
解决：ros进行gazebo仿真，rviz没有显示传感器数据
c++·ubuntu·ros
半盏茶香1 小时前
【C语言】分支和循环详解（下）猜数字游戏
c语言·开发语言·c++·算法·游戏
小堇不是码农1 小时前
在VScode中配置C_C++环境
c语言·c++·vscode
Jack黄从零学c++1 小时前
C++ 的异常处理详解
c++·经验分享
捕鲸叉7 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer7 小时前
【C++】vector 类深度解析：探索动态数组的奥秘
开发语言·c++·算法
Peter_chq7 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
wheeldown8 小时前
【数据结构】选择排序
数据结构·算法·排序算法
青花瓷9 小时前
C++__XCode工程中Debug版本库向Release版本库的切换
c++·xcode
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play