1. Toy模板网首页
  2. > Toy博客

【C++】priority_queue使用与模拟实现

9月前 作者：不 良 分类：Toy博客 阅读(43) 违法举报

这篇具有很好参考价值的文章主要介绍了【C++】priority_queue使用与模拟实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

🚀 作者简介：一名在后端领域学习，并渴望能够学有所成的追梦人。
🚁 个人主页：不 良
🔥 系列专栏：🛸C++  🛹Linux
📕 学习格言：博观而约取，厚积而薄发
🌹 欢迎进来的小伙伴，如果小伙伴们在学习的过程中，发现有需要纠正的地方，烦请指正，希望能够与诸君一同成长！ 🌹

认识priority_queue

1、priority_queue(优先级队列)是一种容器适配器，底层是一个完全二叉树的大堆（堆总是一颗完全二叉树，根结点最大的堆叫做大堆；根结点最小的堆叫做小堆），头文件在queue中，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。不按照先进先出，优先级高的先出，默认数字大的优先级高。

2、类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

3、优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，priority_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是大堆。

容器适配器都是不支持遍历的，不支持范围for。

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

库中priority_queue的定义：

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

默认使用vector作为底层容器。

使用：

#include <queue>
#include <iostream>
using namespace std;
int main()
{
	
	priority_queue<int> pq;
	//默认数字大的优先级高，即默认大堆
	//也可以通过指定模板参数从而让数字小的优先级高,即变成小堆
	//priority_queue<int, vector<int>, greater<int>> pq;
	for (int i = 0; i < 10; i++)
	{
		pq.push(i);
	}
	cout << pq.size() << endl;//输出队列中元素个数 10
	while (!pq.empty())//判断是否为空
	{
		cout << pq.top() << " ";//队头的元素
		pq.pop();//队头元素出队列
	}
	//输出9 8 7 6 5 4 3 2 1 0
	//如果用小堆实现输出0 1 2 3 4 5 6 7 8 9
	return 0;
}

如果想要使优先级队列中小的优先级更高，则可以借助仿函数**greater<int>**，包含在头文件functional中。

priority_queue<int, vector<int>, greater<int>> pq;

仿函数

仿函数都需要重载一个()。仿函数就是重载了一个()，让对象可以像函数一样去使用。

我们来定义一个仿函数：

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

在Less类中我们重载了()，使其成为了能够比较大小的一个运算符：

#include <iostream>
using namespace std;
template<class T>
struct Less {
	bool operator()(const T& l1, const T& l2)
	{
		return l1 < l2;
	}
};
int main()
{
	Less<int> LessFunc;
	cout << LessFunc(2, 3) << endl;//输出1
	return 0;
}

如果只看cout << LessFunc(2, 3) << endl，我们可能会认为LessFunc是一个函数或者函数指针，但是LessFunc是个Less<int>类型的对象，所以我们叫做仿函数。对象可以像函数一样去使用，本质是调用了operator()，运算符重载。

仿函数是为了解决函数指针void(*ptr)()太复杂的问题。

greater<int>和less<int>都是库里面写好的，priority_queue默认使用的是less<int>。

堆算法

**堆的底层是一个数组，**我们先认识两种堆的算法：向上调整法和向下调整法。

向上调整法

向上调整法基本思想（以大堆为例）：

将插入结点作为目标结点，将目标结点和其父结点比较，如果目标结点的值比父结点的值大，则交换目标结点和父结点的位置，交换之后目标结点就变为父结点，然后继续向上调整；如果目标结点的值比父结点的值小，停止调整说明此时该完全二叉树已经是大堆了。

例：我们在下面的大堆最后位置插入数据100，通过向上调整法调整之后使其仍然是一个大堆：

【C++】priority_queue使用与模拟实现,C++,c++,开发语言,后端,priority_queue

此时目标结点就是刚插入的结点，值为100，比父结点值大，所以要将目标结点和父结点交换位置：

【C++】priority_queue使用与模拟实现,C++,c++,开发语言,后端,priority_queue

继续比较并调整，此时目标结点值为100，比父结点值大，交换两者位置：

【C++】priority_queue使用与模拟实现,C++,c++,开发语言,后端,priority_queue

此时调整完成，该树已经调整成大堆了。

向上调整代码如下：

//大堆的向上调整法
void adjust_up(vector<int>& v, int child)
{
	//找出父结点
	int parent = (child - 1) / 2;

	//当child大于0时一直循环，当child = 0时说明已经调整完
	while (child > 0)
	{
		if (v[parent] < v[child])//当parent值小于child值时调整
		{
			swap(v[parent], v[child]);//交换父结点和子结点位置
			child = parent;//此时child等于parent
			parent = (child - 1) / 2;//重新求父结点
		}
		//此时说明已经是大堆了，不需要调整了
		else
		{
			break;
		}
	}
}

向下调整法

使用堆的向下调整算法有一个前提条件：待向下调整的结点的左子树和右子树都必须为大堆。

向下调整法基本思想（以大堆为例）：

将目标结点与自己较大的子结点进行比较，如果目标结点的值比它较大的子结点的值小，则交换目标结点与其较大的子结点的位置，并将较大子结点当作新的目标结点继续向下调整；如果目标结点的值比它较大子结点的值大，则停止向下调整，说明该树已经是大堆。

例：使用向下调整法将下面的完全二叉树调整成大堆（根结点的左右子树已经是大堆）。

【C++】priority_queue使用与模拟实现,C++,c++,开发语言,后端,priority_queue

通过上图我们可以看出其根结点小于右孩子，所以将根结点和右孩子交换：

【C++】priority_queue使用与模拟实现,C++,c++,开发语言,后端,priority_queue

经过上次交换之后，值为60的结点还是小于自己的右孩子，再交换：

【C++】priority_queue使用与模拟实现,C++,c++,开发语言,后端,priority_queue

此时已经调整为大堆。

向下调整法的代码：

//大堆的向下调整
void adjust_down(vector<int>& v,int n,int parent)
{
	int child = (parent * 2) + 1;//求出左孩子
	while (child < n)
	{
		//找到最大孩子结点且保证child合法
		if (child + 1 < n && v[child + 1] > v[child])
		{
			child++;
		}
		if (v[child] > v[parent])//判断孩子结点是否大于父结点
		{
			swap(v[child], v[parent]);//交换结点位置
			parent = child;//重新赋值
			child = (parent * 2) + 1;//重新求出孩子结点
		}
		//已经是大堆
		else
		{
			break;
		}
	}
}

模拟实现priority_queue

优先级队列默认给的容器vector，大堆，数字大的优先级高。

优先级队列底层实际上就是堆结构，通过堆算法实现优先级，堆的底层是一个数组。

我们知道了堆算法的实现，那么priority_queue的模拟实现就变得简单了，其他的操作直接复用容器的函数就可以实现，模拟实现代码如下：

namespace Niu {
	template<class T,class Container = vector<T>>
	class priority_queue {
	public:
		//大堆的向上调整法
		void adjust_up(int child)
		{
			//找出父结点
			int parent = (child - 1) / 2;

			//当child大于0时一直循环，当child = 0时说明已经调整完
			while (child > 0)
			{
				if (_con[parent] < _con[child])//当parent值小于child值时调整
				{
					swap(_con[parent], _con[child]);//交换父结点和子结点位置
					child = parent;//此时child等于parent
					parent = (child - 1) / 2;//重新求父结点
				}
				//此时说明已经是大堆了，不需要调整了
				else
				{
					break;
				}
			}
		}
		//大堆的向下调整
		void adjust_down(int parent)
		{
			int child = (parent * 2) + 1;//求出左孩子
			while (child < _con.size())
			{
				//找到最大孩子结点且保证child合法
				if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				{
					child++;
				}
				if (_con[parent] < _con[child])//判断孩子结点是否大于父结点
				{
					swap(_con[child], _con[parent]);//交换结点位置
					parent = child;//重新赋值
					child = (parent * 2) + 1;//重新求出孩子结点
				}
				//已经是大堆
				else
				{
					break;
				}
			}
		}
		//插入元素
		void push(const T& val)
		{
			_con.push_back(val);//尾插
			adjust_up(_con.size() - 1);//向上调整
		}
		//删除元素
		void pop()
		{
			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;
	};
}

测试：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#include "priority_queue.h"
int main()
{
	
	Niu::priority_queue<int> pq;
	//默认数字大的优先级高，即默认大堆
	for (int i = 0; i < 10; i++)
	{
		pq.push(i);
	}
	cout << pq.size() << endl;//输出队列中元素个数 10
	while (!pq.empty())//判断是否为空
	{
		cout << pq.top() << " ";//队头的元素
		pq.pop();//队头元素出队列
	}
	//输出9 8 7 6 5 4 3 2 1 0
	//如果用小堆实现输出0 1 2 3 4 5 6 7 8 9
	return 0;
}

数值大的优先级高，priority_queue是一个适配器，当我们将底层模板参数更改为deque<T>仍然能运行。

template<class T,class Container = deque<T>>

那此时默认的是数值大的优先级高，如果想让数值小的优先级高可以通过仿函数实现。

注意仿函数定义时>是小堆，<是大堆，定义仿函数的时候运算符要和类名保持一致。

在下面的代码中定义了两个仿函数，同时将向上调整法和向下调整法中的大小比较通过仿函数实现（还可以传一个匿名对象调用仿函数）：

namespace Niu {
    //定义大堆
	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 Container = vector<T>,class Compare = less<T>>
	class priority_queue {
	public:
		//大堆的向上调整法
		void adjust_up(int child)
		{
			Compare com; //此时我们可以使用重载的运算符
			//找出父结点
			int parent = (child - 1) / 2;

			//当child大于0时一直循环，当child = 0时说明已经调整完
			while (child > 0)
			{
				//if (_con[parent] < _con[child])//当parent值小于child值时调整
				if(com(_con[parent],_con[child]))
				{
					swap(_con[parent], _con[child]);//交换父结点和子结点位置
					child = parent;//此时child等于parent
					parent = (child - 1) / 2;//重新求父结点
				}
				//此时说明已经是大堆了，不需要调整了
				else
				{
					break;
				}
			}
		}
		//大堆的向下调整
		void adjust_down(int parent)
		{
			Compare com; //此时我们可以使用重载的运算符
			int child = (parent * 2) + 1;//求出左孩子
			while (child < _con.size())
			{
				//找到最大孩子结点且保证child合法
				//if (child + 1 < _con.size() && _con[child + 1] > _con[child])
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
				{
					child++;
				}
                //if ( _con[parent] < _con[child])
				if (com(_con[parent], _con[child]))//判断孩子结点是否大于父结点
				//还可以传一个匿名对象调用if (com()(_con[parent] , _con[child]))
				{
					swap(_con[child], _con[parent]);//交换结点位置
					parent = child;//重新赋值
					child = (parent * 2) + 1;//重新求出孩子结点
				}
				//已经是大堆
				else
				{
					break;
				}
			}
		}
	private:
		Container _con;
	};
}

测试：

int main()
{	
	//通过指定模板参数从而让数字小的优先级高,即变成小堆
	Niu::priority_queue<int, vector<int>, greater<int>> pq;
	for (int i = 0; i < 10; i++)
	{
		pq.push(i);
	}
	cout << pq.size() << endl;//输出队列中元素个数 10
	while (!pq.empty())//判断是否为空
	{
		cout << pq.top() << " ";//队头的元素
		pq.pop();//队头元素出队列
	}
	//输出0 1 2 3 4 5 6 7 8 9
	return 0;
}

不是内置类型也可以用模板参数比较大小，但是我们要重载>和<运算符，方便在调用仿函数时调用，如下面的日期类代码：

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)
    {
        _cout << d._year << "-" << d._month << "-" << d._day;
        return _cout;
    }
    private:
    int _year;
    int _month;
    int _day;
};
void test_priority_queue2()
{
    // 大堆，需要用户在自定义类型中提供<的重载
    priority_queue<Date> q1;
    q1.push(Date(2018, 10, 29));
    q1.push(Date(2018, 10, 28));
    q1.push(Date(2018, 10, 30));
    cout << q1.top() << endl;
}

我们实现了>和<运算符重载，这样在自定义类型的优先级队列中，当我们push时，在push函数中调用adjust_up函数，而在adjust_up函数中有仿函数的使用，仿函数中有类型比较，整个过程如下图：

【C++】priority_queue使用与模拟实现,C++,c++,开发语言,后端,priority_queue

那此时如果我们想比较两个Date*类型所指向的日期大小我们应该怎么办呢？

Date*可以比较大小，但是不是我们想要的，new出来的地址没有先大先小的概念，完全没有规律。所以我们也可以通过仿函数来比较。

实现两个日期类指针的仿函数（注意要在日期类下面定义）：

class PDateLess{
public:
    bool operator()(const Date* p1, const Date* p2)
    {
        return *p1 < *p2;
    }
};
class PDateGreater{
public:
    bool operator()(const Date* p1, const Date* p2)
    {
        return *p1 > *p2;
    }
};

测试：文章来源地址https://www.toymoban.com/news/detail-594034.html

void test_priority_queue2()
{
    // 大堆，需要用户在自定义类型中提供<的重载
    priority_queue<Date> q1;
    q1.push(Date(2018, 10, 29));
    q1.push(Date(2018, 10, 28));
    q1.push(Date(2018, 10, 30));
    cout << q1.top() << endl;
    //输出2018-10-30

    //priority_queue<Date*,vector<Date*>,PDateLess> q2;//大堆
    priority_queue<Date*, vector<Date*>, PDateGreater> q2;//小堆
    q2.push(new Date(2018, 10, 29));
    q2.push(new Date(2018, 10, 28));
    q2.push(new Date(2018, 10, 30));
    cout << *(q2.top()) << endl;//返回值为日期指针类型，所以要解引用
    //输出2018-10-28
}

到了这里，关于【C++】priority_queue使用与模拟实现的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【C++初阶】仿函数和priority_queue的模拟实现（附源码）

    【C++初阶】仿函数和priority_queue的模拟实现（附源码）

    仿函数，顾名思义就是 模仿函数，它其实是一个类，类里面重载了运算符（） ，在调用这个重载的运算符时，让我们感觉是调用函数一样，可以说相当于C语言里的函数指针一样，但是函数指针的可读性不好，不如仿函数。 1.仿函数即使定义相同，也可能有不同的类型； 2.仿

    2024年02月16日
    浏览(33)
  • C++:stack、queue、priority_queue增删查改模拟实现、deque底层原理

    C++:stack、queue、priority_queue增删查改模拟实现、deque底层原理

    我们先来看看 stack的相关接口有哪些： 从栈的接口，我们可以知道栈的接口是一种特殊的vector，所以我们完全可以使用vector来模拟实现stack。 因此我们可以将底层容器定义成模板，然后将容器类变量作为成员变量进行封装。在实现satck的各种接口时，通过成员变量来调用底层

    2024年02月03日
    浏览(45)
  • 【C++】——栈和队列（stack、queue）及优先队列（priority_queue）的介绍和模拟实现

    【C++】——栈和队列（stack、queue）及优先队列（priority_queue）的介绍和模拟实现

    今天我们来学习C++stl六大组件的其中一种，容器适配器，stack、queue及priority_queue都是容器适配器。我们循序渐进，接下来让我们先认识一下什么是容器适配器。 适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该

    2024年02月08日
    浏览(51)
  • 【C++】STL优先级队列（priority_queue）功能介绍以及模拟实现

    【C++】STL优先级队列（priority_queue）功能介绍以及模拟实现

    点进来的小伙伴不知道学过数据结构里的堆没有，如果学过的话，那就好说了，优先级队列就是堆，如果没学过，没关系，可以参考一下我之前写的一篇关于堆的博客，可以点进去看看：【数据结构】堆（包含堆排序和TOPK问题） 那么了解过堆了的话，我就不讲那么细致了，

    2024年02月16日
    浏览(49)
  • 【STL】priority_queue的使用及模拟实现

    【STL】priority_queue的使用及模拟实现

    目录 前言 priority_queue的使用 功能解析 基本接口 写点题目 模拟实现 结构解析 插入删除 调整函数结合仿函数 仿函数介绍 结合使用 其他功能 接口补齐 迭代器区间构造 🍾打开 queue 头文件后，我们发现除了我们之前介绍过的普通队列以外，还有一个 priority_queue 。 🍾其又名为

    2024年02月08日
    浏览(41)

  • 容器适配器---deque和STL ---stack queue priority_queue的模拟实现 C++

    目录 一、容器适配器 deque原理 deque的缺陷 deque的优势 二、stack的模拟实现  三、queue的模拟实现 四、优先级队列的模拟实现 适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户

    2024年02月02日
    浏览(55)
  • 【C++】STL中的容器适配器 stack queue 和 priority_queue 的模拟实现

    【C++】STL中的容器适配器 stack queue 和 priority_queue 的模拟实现

    适配器是一种设计模式 (设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。 例如我们常见的充电器就是一种适配器，它将我们常用的220V交流电压转化为4，5V (或者其他更高的电

    2023年04月26日
    浏览(61)
  • 【STL详解 —— priority_queue的使用与模拟实现】

    【STL详解 —— priority_queue的使用与模拟实现】

    std::priority_queue 是 C++ 标准库中的容器适配器，它提供了一种基于堆的优先级队列实现。优先级队列是一种特殊的队列，其中的元素按照一定的优先级顺序排列，而不是按照它们被插入的顺序。 在 std::priority_queue 中，插入元素时会根据元素的值自动进行排序，最大（或最小）

    2024年04月17日
    浏览(32)
  • 《priority_queue的模拟实现》

    《priority_queue的模拟实现》

    本文主要介绍 所谓的仿函数(functor)，是通过重载 () 运算符模拟函数形为的类。 因此，这里需要明确两点： 仿函数不是函数，它是个类； 仿函数重载了()运算符，使得它的对你可以像函数那样子调用(代码的形式好像是在调用函数)。（C语言中就是函数指针） 为了适应更多的

    2024年02月07日
    浏览(37)
  • C++——优先级队列(priority_queue)的使用及实现

    C++——优先级队列(priority_queue)的使用及实现

    目录 一.priority_queue的使用 1.1、基本介绍 1.2、优先级队列的定义 1.3、基本操作(常见接口的使用） 1.4、重写仿函数支持自定义数据类型 二.priority_queue的模拟实现 2.1、构造重要的调整算法 2.2、常见接口的实现 push() pop() top() empty()、size()  三.利用仿函数改进调整算法 我们之前

    2024年02月02日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包