【C++】优先级队列 priority_queue的使用及模拟实现@STL —— 仿函数

已于 2022-06-25 09:30:51 修改
阅读量715 收藏 16
点赞数 39
分类专栏： C++ 文章标签： c++ STL 开发语言 算法
于 2022-04-12 16:09:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54851255/article/details/124126372
版权

priority_queue


优先级队列也是一种 容器适配器，默认情况下它适配的是vector，以支持 堆的算法中频繁的随机访问。priority_queue不像stack & queue的适配只是简单复用，还搭配了堆的算法。那么，如何控制大堆还是小堆呢？就要通过简单的 仿函数啦。let’s go!

正文开始

反爬链接

1. 优先级队列的使用

头文件：<queue>

  • Container：默认情况下，它适配的是vector。理论上，底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类，但是必须支持随机访问迭代器访问，以及一系列基本接口。

  • Compare：默认情况下，大的优先级高(即默认是大堆)，仿函数给的是less(这确实有点奇怪)。小堆需要传入仿函数类型，它的头文件在<functional>中。

#include<iostream>
#include<queue>
#include<functional> //greater算法头文件

using namespace std;

int main()
{
	//priority_queue<int> pq; //默认大的优先级高，仿函数为less
	priority_queue<int,vector<int>,greater<int>> pq;

	pq.push(1);
	pq.push(3);
	pq.push(5);
	pq.push(2);
	pq.push(4);
	
    // 适配容器都不能迭代器遍历，因为这样不能保证堆的性质。
	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
	return 0;
}

来一道小题：215. 数组中的第K个最大元素 - 力扣（LeetCode） (leetcode-cn.com)

💜 方法一：排序

时间复杂度：O(N*logN)

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        sort(nums.begin(),nums.end());
        return nums[nums.size()-k]; //倒数第k个
    }
};

或排升序

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        sort(nums.begin(),nums.end(),greater<int>());//注意，传的是匿名 对象
        return nums[k-1];
    }
};

💜 方法二：建大堆(堆排) + pop (k-1)次取堆顶

时间复杂度：O(N+k*logN)

空间复杂度：O(N) 😱

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        priority_queue<int> maxHeap(nums.begin(), nums.end());
        while(--k)
        {
            maxHeap.pop();
        }
        return maxHeap.top();
    }
};
  • 注意：迭代器区间构造，即建堆。不需要遍历push了

如果N>>k，法1和法2的代价太大，我们借鉴topK问题的思路，建一个k个数的小堆 ——

💜 方法三：建一个k个数的小堆 + 取堆顶元素

时间复杂度：O(k+(N-k)*logk)

空间复杂度：O(k)

时间复杂度和法二相差不大，但空间消耗最小，是这道题目的极致写法。

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        //小堆
        priority_queue<int, vector<int>, greater<int>> minHeap(nums.begin(), nums.begin()+k);
        for(int i = k; i<nums.size(); i++)
        {
            if(nums[i]>minHeap.top())
            {
                minHeap.pop();
                minHeap.push(nums[i]);
            }
        }
        return minHeap.top();
    }
};

2. priority_queue的模拟实现

priority_queue框架，它的底层是一个随机容器。模板参数的第三个参数(仿函数)后面详谈——

template<class T,class Container = vector<T>,class Compare = less<T>>
class priority_queue
{
private:
    void ajust_up(size_t child);
    void ajust_down(size_t parent);

public:
    priority_queue()
    {}

    void push(const T& x);
    void pop();

    const T& top() const;
    size_t size() const;
    bool empty() const;

private:
    Container _con;
};

2.1 size & empty & top

一系列简单接口。top是取堆顶元素。

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

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

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

2.2 仿函数

我们写一个类，没有任何成员变量，重载() ——

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

不同仿函数类型的对象，用()来调用对应的函数比较方式，就实现了像函数一样调用 ——

// Less<T> - 仿函数类型，less 仿函数对象
int main()
{
	Less<int> less;
	cout << less(1, 2) << endl;
	cout << less.operator()(1, 2) << endl; // 等价于
    
	cout << Less<int>()(1, 2) << endl; //匿名对象

	Greater<int> greater;
	cout << greater(1, 2) << endl;
	cout << greater.operator()(1, 2) << endl;// 等价于
    
	cout << Greater<int>()(1, 2) << endl; //匿名对象

	return 0;
}

建大堆还是建小堆本质是由于ajust_up和ajust_down中的比较符号不同，那么就要通过仿函数来控制。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-72nz857y-1649750293911)(C:\Users\13136\AppData\Roaming\Typora\typora-user-images\image-20220412155308474.png)]

2.2.1 push & 向上调整算法

优先级队列的插入及删除，就是在堆的基础上做插入删除，堆的算法我们都相当熟悉了。

堆插 = 尾插 + 向上调整

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

💜 向上调整算法

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

2.2.2 pop & 向下调整算法

堆删 = 交换 + 再删(直接头删会破坏树的关系) + 向下调整(刚好符合左右都是大/小堆的条件)

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

💜 向下调整算法

    void ajust_down(size_t parent)
    {
        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() && Compare()(_con[child], _con[child + 1]))
                child++;

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

向上调整和向下调整算法我们都把它实现成私有，因为不太希望别人直接调用。

2.3 构造函数

💜 迭代器区间构造：_con自定义类型会调用它的迭代器区间构造，不用再迭代器遍历+push了。但在这基础上，还需要构建成堆，为了使左右都是大(小)堆，要倒着建，从最后一个非叶子节点(即最后一个节点的父亲)开始向下调整。

	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--)
			{
				ajust_down(i);
			}
		}

2.4 关于T是自定义类型

我们考虑，当T是自定义类型(比如Date)时 ——

	void test_priority_queue2()
	{
		//priority_queue<Date> pq;
		priority_queue<Date, vector<Date>, greater<Date>> pq;
		pq.push(Date(2022, 3, 26));
		pq.push(Date(2022, 4, 1));
		pq.push(Date(2022, 2, 19));
		pq.push(Date(2022, 4, 10));

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

在仿函数中，<和>运算符是无法直接比较的。of course 我们可以重载运算符like this ——

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

但是如果数据类型 不支持比较 或 比较的方式不是你想要的，可以自己实现仿函数，按照你想要的方式(Compare给我们留的口子)去控制比较逻辑，比如 ——

	void test_priority_queue3()
	{
		//priority_queue<Date*> pq; //默认比较地址大小
		//priority_queue<Date*, vector<Date*>, lessPDate> pq;
		priority_queue<Date*, vector<Date*>, greaterPDate> pq;
		pq.push(new Date(2022, 3, 26));
		pq.push(new Date(2022, 4, 1));
		pq.push(new Date(2022, 2, 19));
		pq.push(new Date(2022, 4, 10));

		//默认比较地址大小，若想比较日期大小，自己写仿函数
		while (!pq.empty())
		{
			cout << *pq.top() << endl;
			pq.pop();
		}
	}

于是我们自己写了仿函数，又因为私有成员类外无法访问，我们把这两个仿函数类声明为priority_queue的友元类 ——

	struct lessPDate
	{
		bool operator()(const Date* d1,const Date* d2)
		{
			//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);
		}
	};

	struct greaterPDate
	{
		bool operator()(const Date* d1, const Date* d2)
		{
			//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);
		}
	};

附：priority_queue.h

如果你被东一块儿西一块儿的代码搞晕了哈哈，欢迎通读.h文件 ——

#pragma once
#include<iostream>
#include<vector>

using namespace std;

namespace beatles
{
	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>,class Compare = less<T>>
	class priority_queue
	{
	private:
		void ajust_up(size_t child)
		{
			while (child > 0)
			{
				size_t parent = (child - 1) / 2;
				//if (_con[parent] < _con[child]) //默认大堆的情况下
				if (Compare()(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					child = parent;
				}
				else
				{
					break;
				}
			}
		}

		void ajust_down(size_t parent)
		{
			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() && Compare()(_con[child], _con[child + 1]))
					child++;

				//if (_con[parent],<_con[child]) //默认大堆的情况下
				if (Compare()(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					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 >= 0; i--)
			{
				ajust_down(i);
			}
		}

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

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

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

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

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

	private:
		Container _con;
	};

	// 测试尾插尾删，同时测试了向上调整&向下调整算法
	void test_priority_queue1()
	{
		//priority_queue<int> pq; //默认大的优先级高，仿函数为less
		priority_queue<int, vector<int>, greater<int>> pq;

		pq.push(1);
		pq.push(3);
		pq.push(5);
		pq.push(2);
		pq.push(4);

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

	class Date
	{
		friend struct lessPDate;
		friend struct greaterPDate;

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

	// 对于自定义类型，可以重载>和<
	// 如果数据类型不支持比较 或 比较的方式不是你想要的
	// 可以自己实现 仿函数，按照你想要的方式去控制比较逻辑
	void test_priority_queue2()
	{
		//priority_queue<Date> pq;
		priority_queue<Date, vector<Date>, greater<Date>> pq;
		pq.push(Date(2022, 3, 26));
		pq.push(Date(2022, 4, 1));
		pq.push(Date(2022, 2, 19));
		pq.push(Date(2022, 4, 10));

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

	struct lessPDate
	{
		bool operator()(const Date* d1,const Date* d2)
		{
			//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);
		}
	};

	struct greaterPDate
	{
		bool operator()(const Date* d1, const Date* d2)
		{
			//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 test_priority_queue3()
	{
		//priority_queue<Date*> pq; //默认比较地址大小
		//priority_queue<Date*, vector<Date*>, lessPDate> pq;
		priority_queue<Date*, vector<Date*>, greaterPDate> pq;
		pq.push(new Date(2022, 3, 26));
		pq.push(new Date(2022, 4, 1));
		pq.push(new Date(2022, 2, 19));
		pq.push(new Date(2022, 4, 10));

		//默认比较地址大小，若想比较日期大小，自己写仿函数
		while (!pq.empty())
		{
			cout << *pq.top() << endl;
			pq.pop();
		}
	}
    
}

持续更新@边通书

浮光 掠影
关注
  • 39
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 25
    评论
专栏目录
数据结构课程设计优先队列数据（priority_queue）类型
03-27
在数据结构课程设计中，优先队列数据类型（priority_queue）是核心概念之一，常用于实现高效的调度、搜索和优化问题。在本项目中，我们将讨论如何实现这种数据结构以及其主要操作。 **一、优先队列的定义** 优先...
STL.rar_c++ 容器使用
09-24
7. **优先队列(Priority_Queue)**：优先队列是一种特殊的队列，其中元素按照优先级进行排列，每次删除具有最高优先级的元素。 STL容器的使用涉及到的关键概念包括迭代器（Iterator），它是访问容器内元素的一种方式...
C++ STL：优先级队列priority_queue的使用方法和模拟实现
weixin_43908419的博客
04-04 1227
本文对优先级队列的结构、常见接口的使用方法及模拟实现进行了详细解读
C++优先级队列priority_queue详解及其模拟实现
qq_61635026的博客
07-15 1318
C++优先级队列priority_queue详解及其模拟实现
【C++】优先级队列priority_queue模拟实现&&仿函数
weixin_46016019的博客
04-07 1347
详细介绍priority_queue优先级队列的模拟实现，以及基础仿函数的介绍使用
C++优先级队列priority_queue模拟实现
BoJerry777的博客
05-01 782
优先级队列是一种容器适配器，优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下priority_queue是大堆。priority_queue默认vector作为容器，默认情况下为大堆。//默认//显示为大堆若是容器为vector，结构为小堆。
优先级队列 priority_queue 的使用及示例代码
qq_44667259的博客
03-14 971
优先级队列（priority_queue）是一种特殊的队列，其中的元素按照一定的优先级顺序排列，使得每次都可取出具有最高优先级的元素。本文介绍了优先级队列的基本概念、简要介绍了STL中的priority_queue的定义和主要操作，并给出了示例代码。
【C++】STL——容器适配器priority_queue(优先级队列)详解 及 仿函数的介绍和使用
m0_70980326的博客
05-22 3383
深度剖析容器适配器priority_queue（优先级队列）的底层结构及其模拟实现，介绍什么是仿函数，及仿函数的简单应用
【C++优先级队列priority_queue基础】基本使用，模拟实现，堆
qq_43727529的博客
07-30 856
朋友们好,这篇博客我们继续C++的初阶学习，最近我学习了C++中的STL库中的优先级队列（priority_queue）容器适配器，对于优先级队列，我们不仅要会使用常用的函数接口，我们还有明白这些接口在其底层是如何实现的。所以特意整理出来一篇博客供我们学习和,如果文章中有理解不当的地方,还希望朋友们在评论区指出,我们相互学习,共同进步!......
【C++】STL使用仿函数控制优先级队列priority_queue
邓富民的博客
07-22 1746
本文章讲解C++STL的容器适配器：priority_queue的实现，并实现仿函数控制priority_queue底层。本文章讲解了仿函数控制priority_queue容器的底层实现的过程以及priority_queue的底层实现。只要有堆的地方就可以使用priority_queue容器。
[STL]优先级队列priority_queue
Protein_zmm的博客
07-25 1016
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作empty()...
c++API.zip_-baijiahao_C++帮助文档_Load c++_STL库_stl API
09-20
6. 适配器：如stack、queue、priority_queue，它们将基础容器包装成特定的行为模式，如后进先出（LIFO）的栈、先进先出（FIFO）的队列和优先级队列。 在"C++API.chm"文件中，你可以找到关于这些组件的详细说明，...
STL_C++stl实现_
10-01
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中的一部分，它提供了丰富的容器、迭代器、算法和函数对象等组件，极大地提高了C++的可重用性和效率。STL的主要目标是提供一种高效且灵活的...
STL_quene.rar_crowd7oc_优先队列 堆_大根堆_大根对 c++_小根堆
09-24
C++的STL中，`<queue>`库提供了优先队列的接口，但底层实现通常基于堆。你可以通过指定容器类型为`std::priority_queue`来创建一个优先队列。默认情况下，它使用大根堆，但可以通过自定义比较函数来实现小根堆。 ...
【C语言】简易版扫雷游戏（数组、函数的练习）
最新发布
2401_86272648的博客
07-25 1319
打印时，等于9或10的位置打印' * '，小于等于8的位置打印周围雷个数。但是这样在打印时会多一些判断，写代码时也容易混淆雷位置信息和雷个数信息，读代码的人理解起来也没有分成两个数组容易。因为有字符' * '，所以存周围雷个数的数组的元素用char类型；虽然存雷位置的数组都是数字0和1，但是统一起见，元素的类型都定义为char，这样写代码的时候不容易搞错。② 打印在控制台的扫雷画面（未排雷的位置显示 ' * ' ，已排雷且非雷的位置显示周围雷的个数）。排雷时，如果找到非雷，则显示周围雷的个数。
背单词工具(C++)
zeyeqianli的博客
07-24 4058
【代码】背单词工具(C++)
C++的STL简介（一）
2302_81171591的博客
07-23 1703
STL（standarf template libaray-标准模板库）：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
C语言：扫雷游戏实现
zm3rttqs9f的博客
07-25 2203
扫雷游戏想必大家都玩过吧，初级的玩法是在一个9*9的棋盘上找到没有雷的格子，而今天我们就要做的就是9*9扫雷游戏的实现。
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浮光 掠影

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值