C++---由优先级队列认识仿函数

最新推荐文章于 2024-09-09 12:31:15 发布

应茶茶

最新推荐文章于 2024-09-09 12:31:15 发布

阅读量986

点赞数 20

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2302_76267737/article/details/141967334

版权

C++ 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

前言

本文主要介绍了优先级队列是什么，如何使用优先级队列，并且由优先级队列引出仿函数，从中认识仿函数，最后了解一下什么是适配器。

一、优先级队列是什么？

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

二、如何使用优先级队列

1、优先级队列容器用法

我们从cplusplus网站中看一些优先级队列的结构：

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

我们用一段代码来带大家初步认识：

#include <vector>
#include <queue>
#include <functional> // greater算法的头文件
void TestPriorityQueue()
{
 // 默认情况下，创建的是大堆，其底层按照小于号比较
 vector<int> v{3,2,7,6,0,4,1,9,8,5};
 priority_queue<int> q1;
 for (auto& e : v)
 q1.push(e);
 cout << q1.top() << endl;
 // 如果要创建小堆，将第三个模板参数换成greater比较方式
 priority_queue<int, vector<int>, greater<int>> q2(v.begin(), v.end());
 cout << q2.top() << endl;
}

这段代码打印的结果是堆顶的数据，如果是大堆，那么堆顶就是最大的，反之堆顶的数据就是最小的。

打印结果：

打印第一行就是默认大堆的结果，第二行是我们增加了参数模板改成了小堆。

我们看到这里第一想法就是，可以用优先级队列来排序，是的没错，但是你将容器中的数打印出来却发现并不是有序的，只是符合了大堆的性质

2、为什么容器本身无序？

我们都知道了他是大堆，每次取出顶部元素之后删除顶部元素再进行向下调整取出第二个最大元素，所以我们就知道，有序的不是容器本身，而是我们从堆顶依次取出的数据。

我们用默认大堆，将堆顶的数据依次取出查看顺序结果：

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

三、什么是仿函数？

在我们上面优先级队列使用时，我们想将默认大堆改成小堆，因此我们添加了额外的两个参数模板，其中控制大小堆变化的就是第三个参数greater<int>

在C++中，仿函数或函数对象是通过重载operator()的类实例来模拟函数行为的对象。这种特性使得C++的对象可以像函数一样被调用，从而为编程提供了极大的灵活性和强大的功能。

1. 什么是仿函数？

仿函数是一个类，它定义了一个或多个operator()成员函数，使得其对象可以像普通函数那样被调用。仿函数通常用于以下场景：

作为算法的比较函数
作为算法的操作函数
存储状态或属性，使行为可定制

2. 仿函数的优势

与普通函数和函数指针相比，仿函数具有以下优势：

状态维护：仿函数可以持有状态，每次调用可以根据状态改变行为。
内联调用：由于仿函数是通过对象调用的，编译器可以轻易地将其内联，减少调用开销。
高度定制：可以通过对象的属性来调整其行为。

四、仿函数如何使用？

我们通过对优先级队列的实现，写出一个可以作为比较函数的仿函数

我们先在头文件中写出默认大堆的代码，实现优先级队列的几个功能：

代码如下：

#pragma once
#include<queue>
#include<vector>
#include<algorithm>
	
using namespace std;
namespace bit
{
	template<class T, class Container = vector<T>>
	class priority_queue
	{
	public:
		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (_con[parent]< _con[child])
				{
					swap(_con[child], _con[parent]);
					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()&& _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 push(const T& x)
		{
			_con.push_back(x);
			adjust_up(_con.size() - 1);
		}
		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}
		bool empty()
		{
			return _con.empty();
		}
		const T& top()
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
	private:
		Container _con;

	};
}

我们这个是默认大堆的，创建对象之后，每次取出堆顶的数据只会是最大了那个数据，因为我们在向上调整或者向下调整时，全都是大堆的比较方法，所以我们只能用大堆。

那我们应该如何切换小堆呢？

1、重载operator()函数

我们重载operator()函数使其成为一个可以被调用的可以比较大小的函数

代码如下：

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

在这两个比较函数中，less就是大堆的比较方法，而greater就是小堆的比较方法

2、运用第三个参数模板

我们知道，我们所写的operator()函数是在类里面，所以这个类就可以作为一个类模板去使用

我们在第三个参数模板中写一个比较模板，用来切换在向上调整或者向下调整中的比较方法，进而去切换大小堆

模板代码：

template<class T, class Container = vector<T>,class Compare=less<T>>

我们将第三个模板命名为Compare ,后面调用less类的比较方法，在默认情况下仍是大堆。

接下来，我们可以把向上调整或者向下调整中的比较方法修改成我们的仿函数。

先创建Compare对象

Compare com;

接下来开始替换(向上调整举例)：

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

我们可以看到，我们在if判断语句中的比较已经改成了我们的仿函数。

3、大小堆切换

当我们想要从大堆切换小堆时，我们直接改变第三个参数模板的底层类就可以了，将less<T>修改成greater<T>即可(头文件和源文件的模板都要修改)

template<class T, class Container = vector<T>,class Compare=greater<T>>

我们进行一下测试：

大堆测试代码：

void Test_priority_queue()
{
	bit::priority_queue<int,vector<int>,less<int>> pq;
	pq.push(2);
	pq.push(7);
	pq.push(1);
	pq.push(8);
	while (!pq.empty())
	{	
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
}
int main()
{
	Test_priority_queue();
	return 0;
}

打印结果：

小堆测试代码：

void Test_priority_queue()
{
	bit::priority_queue<int,vector<int>,greater<int>> pq;
	pq.push(2);
	pq.push(7);
	pq.push(1);
	pq.push(8);
	while (!pq.empty())
	{	
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
}
int main()
{
	Test_priority_queue();
	return 0;
}

打印结果：

4、头文件总代码

#pragma once
#include<queue>
#include<vector>
#include<algorithm>
	
using namespace std;
namespace bit
{
	//仿函数，切换大堆小堆，仿函数作为一个类型，可以作为类模板使用
	template<class T>
	class less
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};
	template<class T>
	class greater
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};
	template<class T, class Container = vector<T>,class Compare=greater<T>>
	class priority_queue
	{
	public:
		void adjust_up(size_t child)
		{
			Compare com;
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				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 = parent * 2 + 1;
			while (child < _con.size())
			{
				if ( child + 1 < _con.size()&& com(_con[child], _con[child + 1]))
				{
					child++;
				}
				if (com(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}

		}
		void push(const T& x)
		{
			_con.push_back(x);
			adjust_up(_con.size() - 1);
		}
		void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}
		bool empty()
		{
			return _con.empty();
		}
		const T& top()
		{
			return _con[0];
		}
		size_t size()
		{
			return _con.size();
		}
	private:
		Container _con;

	};
}

五、什么是容器适配器？

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

应茶茶

关注

20
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
C++---由优先级队列认识仿函数

本文主要介绍了优先级队列是什么，如何使用优先级队列，并且由优先级队列引出仿函数，从中认识仿函数，最后了解一下什么是适配器。在我们上面优先级队列使用时，我们想将默认大堆改成小堆，因此我们添加了额外的两个参数模板，其中控制大小堆变化的就是第三个参数greater在C++中，仿函数或函数对象是通过重载operator()的类实例来模拟函数行为的对象。这种特性使得C++的对象可以像函数一样被调用，从而为编程提供了极大的灵活性和强大的功能。仿函数是一个类，它定义了一个或多个operator()
复制链接

扫一扫

专栏目录