[STL]优先级队列priority_queue

已于 2022-07-25 13:50:55 修改
阅读量1k 收藏 9
点赞数 1
分类专栏： C++ 文章标签： c++ 算法
于 2022-07-25 13:50:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51304981/article/details/125969212
版权

目录

一、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是大堆。

// 默认是大堆
void test_priority_queue()
{
	priority_queue<int> pq; // 头文件queue
	pq.push(3);
	pq.push(3);
	pq.push(7);
	pq.push(1);
	pq.push(9);

	while (!pq.empty())
	{
		cout << pq.top() << " "; // 取优先级最高的，默认是大的优先级高
		pq.pop();
	}
	cout << endl;
}

如果想让小的优先级高怎么办？
控制小的优先级高——传greater的仿函数

#include <functional> // greater的头文件
void test_priority_queue()
{
	// 要传第三个模板参数前提是要有第二个模板参数
	priority_queue<int, vector<int>, greater<int>> pq; // 最好不去使用deque，因为堆可能数据很大
	pq.push(3);
	pq.push(3);
	pq.push(7);
	pq.push(1);
	pq.push(9);

	while (!pq.empty())
	{
		cout << pq.top() << " "; // 取优先级最高的，默认是大的优先级高
		pq.pop();
	}
	cout << endl;
}

三、topK - 数组中的第K个最大元素

215. 数组中的第K个最大元素
在这里插入图片描述
方法一：先排序
sort(迭代器区间)：默认升序，要降序就传greater的仿函数
O(NlogN)

// 排升序
class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        return nums[nums.size() - k];
    }
};
// 下标 0 1 2 3 4  size = 5, k = 1
// 元素 1 2 3 4 5 第一个大的就是5

// 排降序
class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end(), greater<int>()); // 仿函数是一个自定义类型
        return nums[k - 1];
    }
};
// 0 1 2 3 4  size = 5, k = 1 第一个大的就是k - 1 对应的元素 5
// 5 4 3 2 1

对比刚刚priority_queue和sort中传的greater可以发现明显的不一样，原因是：
在这里插入图片描述
方法二：大堆
建堆时间O（N）+ O(KlogN)

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        priority_queue<int> maxHeap(nums.begin(), nums.end()); // 建N个数的大堆
        // 将前k-1个删掉
        while (--k) // 走k-1次
        {
            maxHeap.pop();
        }
        return maxHeap.top();
    }
};

方法三：建K个数的小堆
O(K)的空间复杂度

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        // 如果n很大，且n远大于K
        // 建一个K个数的小堆
        priority_queue<int, vector<int>, greater<int>> minHeap(nums.begin(), nums.begin() + k); // O(K)
        // 剩下的N-K个数，依次与堆顶数据比较，比他大就替换他进堆
        for (size_t i = k; i < nums.size(); ++i)
        {
            if (nums[i] > minHeap.top())
            {
                minHeap.pop();
                minHeap.push(nums[i]);
            }
        } // O((N-K) * logK)
        // 前K个大的数都在堆里面，求第K个大的就是堆顶的值(因为是小堆)
        return minHeap.top();
    }
    // O( K + (N-K) * logK)
};

四、priority_queue模拟实现

namespace zmm
{
	// 默认大堆
	template<class T, class Container = vector<T>>
	class priority_queue
	{
	private:
		// 不希望别人随意去调用他
		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (_con[child] > _con[parent])
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void adjust_down(size_t parent) // 前提：左右子树都是小堆或是大堆
		{
			size_t child = 2 * parent + 1; // 默认指向左孩子
			while (child < _con.size()) // 调到叶子停止
			{
				if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				{
					child++;
				}
				if (_con[child] > _con[parent])
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = 2 * parent + 1;
				}
				else
				{
					break;
				}
			}
		}

	public:
		priority_queue()
		{}
		
		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			:_con(first, last)
		{
			// 要构建为堆
			// 从最后一个非叶子开始调整建堆
			// i 不能用size_t
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; --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()
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}

	private:
		Container _con; // 自定义类型会调用它的构造函数
	};
}

在这里我们实现的是大堆，但是如果要改为小堆，还需要改adjustup和adjustdown中的符号关系，这就比较麻烦了，所以我们采用一种仿函数的方式来解决这个问题

4.1 仿函数

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

int main()
{
	// 在这里，less和gt像函数名，或像函数指针，可以像函数一样去调用
	Less less; // Less是一个类，定义一个对象
	cout << less(1, 2) << endl; 

	Greater gt;
	cout << gt(1, 2) << endl; // 等价于gt.operator()(1,2)
	return 0;
}

在这里，Less称为仿函数类型，less叫做函数对象

上述代码只适用于int类型，因此我们在添加上模板参数

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

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

int main()
{
	Less<int> less; // Less是一个类，定义一个对象
	cout << less(1, 2) << endl; 
	// 或者可以这样写
	cout << Less<int>()(1, 2) << endl;
	cout << Less<double>()(1.1, 1.2) << endl;


	Greater<int> gt;
	cout << gt(1, 2) << endl; // 等价于gt.operator()(1,2)
	return 0;
}

仿函数是一个类型，类型可以通过模板参数来传递

这样子，我们就可以通过仿函数的方式，修改了模拟实现的代码

namespace zmm
{
	// 默认大堆 -> Less
	// 仿函数是一个类型->可以通过模板参数传递
	template<class T>
	struct Less
	{
		// 左＜右
		bool operator()(const T& x, const T& y) const
		{
			return x < y;
		}
	};


	// 小堆
	template<class T>
	struct Greater
	{
		bool operator()(const T& x, const T& y) const
		{
			return x > y;
		}
	};


	template<class T, class Container = vector<T>, class Compare = Less<T>> // 默认是Less大堆
	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]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void adjust_down(size_t parent) // 前提：左右子树都是小堆或是大堆
		{
			Compare com;
			size_t child = 2 * parent + 1; // 默认指向左孩子
			while (child < _con.size()) // 调到叶子停止
			{
				// if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				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[parent], _con[child]);
					parent = child;
					child = 2 * parent + 1;
				}
				else
				{
					break;
				}
			}
		}

	public:
		priority_queue()
		{}
		
		template <class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			:_con(first, last)
		{
			// 要构建为堆
			// 从最后一个非叶子开始调整建堆
			// i 不能用size_t
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; --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()
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}

	private:
		Container _con; // 自定义类型会调用它的构造函数
	};
}

4.2 仿函数的应用

如果数据类型不支持比较，或者比较的方式不是你想要的，可以通过仿函数，自己去控制比较逻辑

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 test_priority_queue2()
{
	priority_queue<Date, vector<Date>> pq;
	pq.push(Date(2022, 3, 26));
	pq.push(Date(2021, 10, 26));
	pq.push(Date(2023, 3, 26));

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

struct LessPDate
{
	bool operator()(const Date* d1, const Date* d2) const
	{
		return *d1 < *d2;
	}
};
void test_priority_queue3()
{
	priority_queue<Date*, vector<Date*>, LessPDate> pq;
	pq.push(new Date(2022, 3, 26));
	pq.push(new Date(2021, 10, 26));
	pq.push(new Date(2023, 3, 26));

	while (!pq.empty())
	{
		cout << *pq.top(); // 这时候就不是按大小排了，这里是比较的指针（地址）大小
		// 那想要进行日期大小比较怎么办？ —— 增加 class LessPDate
		// 如果数据类型不支持比较，或者比较的方式不是你想要的，可以通过仿函数，自己去控制比较逻辑
		pq.pop();
	}
	cout << endl;
}


int main()
{
	test_priority_queue3();
	return 0;
}
Protein_zmm
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构课程设计优先队列数据（priority_queue）类型
03-27
数据结构课程设计优先队列数据（priority_queue）类型实现优先队列的初始化，查找，插入，删除操作，并且控制其查找，插入，删除操作的算法时间复杂度为O（logn）。
STL中priority_queue
03-07
priority_queue 是 STL 中的一种容器，可以实现优先级队列的功能。下面，我们将详细介绍 priority_queue 的使用方法和实现原理。 priority_queue 的基本概念 priority_queue 是一种特殊的队列，它可以自动对元素...
【C++入门到精通】C++入门 —— priority_queue(STL)优先队列
Yawesh的博客
08-22 9583
本文介绍了priority_queue的概念、特点和使用方法。priority_queue是C++标准库中的一个容器适配器，实现了优先队列的数据结构。优先队列中的元素按照优先级进行排列，可以高效地访问和删除具有最高优先级的元素。我们讨论了priority_queue的基本操作，如插入、删除、访问和判断队列是否为空，以及底层结构的实现原理。此外，还介绍了在priority_queue中使用的仿函数，它决定了元素之间的排序规则。通过了解priority_queue的相关知识，读者可以更好地应用它来解决实际编程中
【C++】STL学习之优先级队列
最新发布
Aron的博客
05-01 1358
优先级队列是容器适配器中的一种，常用来进行对数据进行优先级处理，比如优先级高的值在前面，这其实就是初阶数据结构中的堆，它俩本质上是一样东西，底层都是以数组存储的完全二叉树，不过优先级队列中加入了泛型编程的思想，并且属于STL中的一部分。
STL篇：堆与优先级队列
RTX__90的博客
08-05 268
向下调整建堆条件是左右子树均是大/小堆（所以从倒数第一个非叶子节点开始调整），这种方法的效率比向上调整建堆效率高。向下调整建大堆：从倒数第一个非叶子节点开始调整（大的向上调整，小的向下调整）（时间复杂度：logn）5、topk问题：找最大的前k个数，要（将前k个数）建小堆，交换头尾，再将头向下调整。错误：建小堆，如果挪动删除，剩下的看作堆，选次小的，但是关系乱了，得重新建堆。正确方式：交换头尾，pop掉尾，头向下调整（哪个儿子大，调哪个）正确：建大堆，交换，向下调整（跟删除数据一样的思路）
STL 优先队列 priority_queue
Sylvia_Wu51的博客
03-16 1187
在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列是一个队列，具有队列的所有特性，包括队列的基本操作，在这基础上添加了内部的一个排序(堆排序)，它本质是一个堆实现的。 priority_queue<Type, Container, Functional> 当需要用自定义的数据类型时才需要传入 Type, Container, Functional 这三个参数，使用基本数据类型时，只需要传入数据类型，默认是大顶堆。 Type: 数据类型 Container: 容器
STL之priority_queue
李志杰的博客
10-09 561
目录 1.什么是priority_queue? 2.priority_queue的原型 3.大根堆和小根堆 1.什么是priority_queue? priority_queue本质上是一个堆，再头文件#include<queue>中，可以理解为大根堆或小根堆。 2.priority_queue的原型 priority_queue的原型为： priority_qu...
【C++】-- STL容器适配器之priority_queue
局部变量和全局变量
06-18 2350
priority_queue即优先级队列，是一种容器适配器，最大元素放在第一个。底层用堆实现，默认是大堆，因为默认大的优先级高，可随时插入元素，可快速查找最大元素，即优先级队列中第一个元素。优先级队列元素从特定容器的“尾部”弹出，其称为优先队列的顶部。底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问...
STL priority_queue（优先队列）详解
09-01
STL中的`priority_queue`是一种特殊的容器适配器，它模拟了一个优先队列的数据结构。优先队列的主要特性是每次从队列头部取出的是具有最高优先级的元素，即最大值（默认情况下）。这个数据结构在很多算法和问题中都...
STL-queue--.rar_stl queue
09-24
STL队列常用于任务调度、消息传递、优先级队列（通过结合`priority_queue`实现）、网络缓冲区管理等场景。线段树则广泛应用于动态规划、几何问题、字符串处理等领域，对于需要高效处理区间数据的问题非常有用。 ...
优先级队列
11-28
在C++编程语言中，STL（Standard Template Library，标准模板库）提供了一个名为`<queue>`的头文件，但它并不直接支持优先级队列。为了实现优先级队列，我们需要引入`<priority_queue>`头文件。C++中的`std::...
priority_queue(优先级队列的模拟使用和实现)
拾至名瑰的博客
09-02 579
今天我来讲优先级队列的内容，优先级队列的接口本质和队列是一样的，也是在队列的两端操作，唯一的区别就是优先级队列中(默认)获得队头元素是这个序列中最小的元素。正文开始。
STL中的优先队列
稚与的博客
07-12 1210
STL中的priority queue 文章目录STL中的priority queuepriority_queue 优先队列程序演示 priority_queue 优先队列 以前已经提到过队列（queue）了，队列是一种”先进先出“的数据结构，即元素在队列尾部增加，在队列头部删除（也就是平常所说的“排队”）。 在现实生活中，【为了参与建设和谐美好的现代化社会】，我们在排队时会被道义约束而去让某些人群“优先”。比如说公交车上的老弱病残专座，亦或是讲台旁边的为某些学生提供的“专座”，不一而足。 总之，优先队列的
STL 优先级队列
坤哥的专栏
11-18 1007
STL中优先级队列的模版声明中有三个参数，priority_queue,故名思义，Type为数据类型，Container则是必须用数组实现的容器，常见的vector,deque,但不能用List,STL默认的是vector,后面的Functional为比较方式，默认的基本类型为数值大的优先。即首元素是最大值。 那么在解决问题时，有时会用到最小堆，即优先级队列中首元素为最小的元素，对于基本类型，可
【原创】优先队列 priority_queue 详解
热门推荐
致上
04-25 13万+
c++ 的 stl 里的 优先队列 priority_queue 的声明和基本操作
c++优先队列(priority_queue)用法详解
专心扫地
04-22 316
https://blog.csdn.net/weixin_36888577/article/details/79937886
STL 之 优先队列(priority_queue)
Enstein_Jun
08-10 1万+
1、什么是优先队列        能够完成下列两种操作的数据结构，我们便称之为优先队列。        ①插入一个数值    ②取出最大(或者最小)的数值(获取数值，并且删除)。        从严格意义上来说优先队列，并不是队列，因为它并不遵循队列的FIFO(先进先出的原则)。 2、实现优先队列       我们可以使用一种叫做“堆(heap)”的数据结构来实现优先队列。堆有一个重要的
STL源码分析之priority_queue优先级队列
啦啦啦
12-05 754
前言 上一节分析heap其实就是为priority_queue做准备. priority_queue是一个优先级队列, 是带权值的. 支持插入和删除操作, 其只能从尾部插入,头部删除, 并且其顺序也并非是根据加入的顺序排列的. priority_queue因为也是队列的一种体现, 所以也就跟队列一样不能直接的遍历数组, 也就没有迭代器. priority_queue本身也不算是一个容器, 它是以v...
STL中的优先级队列priority_queue
weixin_30807779的博客
04-29 103
priority_queue(queue类似)完全以底部容器为根据，再加上二叉堆（大根堆或者小根堆）的实现原理，所以其实现非常简单，缺省情况下priority_queue以vector作为底部容器。另外priority_queue缺省比较规则是less: class Compare = less<typename Sequence::value_type> less对应的是...
STL优先级队列(priority_queue)详解：堆算法与容器应用
优先级队列（priority_queue）是C++标准模板库（Standard Template Library, STL）中的一个重要组成部分，它扩展了普通队列（queue）的概念，实现了按照优先级对元素进行排序和管理。不同于FIFO（先进先出）的队列，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值