目录
仿函数
仿函数（Functor）是一个类/结构体，其内部重载了operator()运算符，使其可以像函数一样被调用；
- 由于模版参数接收类型，仿函数是一个类，可以通过 类名/类名<数据类型> 传递给模版参数；
- 仿函数是一个类，则其可以定义对象，对象调用operator()完成控制作用；
示例一：
//带模版参数的仿函数
template<class T>
struct Greater
{
//重载operator()
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
void Func()
{
int x = 10;
int y = 20;
//创建一个仿函数对象
Greater<int> Great;
//通过对象调用仿函数
cout << Great(x, y) << endl;
//cout<<Great.operator()(x,y)<<endl;
//通过匿名对象调用仿函数
cout << Greater<int>()(x, y) << endl;
}
int main()
{
Func();
return 0;
}
示例二 :
//此模版参数接收数据类型
template<class T>
struct Greater
{
//重载operator()称为仿函数/函数对象
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
//此模版参数接收仿函数类型
template<class compare>
class A
{
public:
void func(int a, int b)
{
compare com;
cout << com(a, b) << endl;
//com(a,b)--->com.operator()(a,b)--->com为仿函数对象
}
};
int main()
{
//A类中传递仿函数类型Greater<T>-->仿函数类中传递数据类型Greater<int>
A<Greater<int>> aa1;
aa1.func(10, 20);
A<Greater<int>>aa2;
aa2.func(20, 10);
return 0;
}
具有相同功能的代码可以在不同的类中用到，但是不好将功能相同的代码实现成某一个类的成员函数，仿函数实现了一个简单的类，将需要复用的代码实现在operator()重载函数中，外部函数需要使用时只要用这个类实例化出一个对象，就可以像使用函数一样来使用这个对象，完成对应功能；
常见的仿函数
template <class T>
struct less
{
bool operator() (const T& x, const T& y) const
{
return x<y;
}
};
//std::less<T>: 对于基本数据类型和自定义类型，默认使用<运算符进行比较;
template <class T>
struct greater
{
bool operator() (const T& x, const T& y) const
{
return x>y;
}
};
//std::greater<T>: 对于基本数据类型和自定义类型，默认使用>运算符进行比较;除了c++标准库所提供的仿函数外，可以自定义仿函数来实现自定义的元素比较规则，自定义仿函数需要满足严格弱排序的要求，即：
- 比较关系必须是可传递的：对于任意元素a、b和c，如果a与b比较相等，b与c比较相等，则a与c比较也相等；
- 比较关系不能是部分顺序：对于任意元素a和b，它们不能同时大于、小于或等于彼此；
- 比较关系必须是可比较的：比较关系的结果必须对所有元素定义明确的大小关系；
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来自动完成此操作；
注意：
- 由于优先队列底层数据结构为堆，堆的删除是删除堆顶数据，首先将堆顶数据与最后一个数据交换位置，其次删除数组中最后一个元素，所以容器中要求pop_back()；
- 由于优先队列底层数据结构为堆，堆的插入是数组的尾元素的下一个位置插入数据，然后利用向上调整算法调整为堆，所以容器中要求push_back()；
- 默认情况下，priority_queue使用std::less作为比较函数，创建的是大堆；如果需要按照从小到大的顺序排列，可以使用std::greater作为比较函数，创建的是小堆；
堆的相关知识点回顾：数据结构之堆-CSDN博客
priority_queue官方文档：priority_queue - C++ Reference
priority_queue的常用接口
int main()
{
//未给定仿函数比较方式,默认创建大根堆
priority_queue<int, vector<int>> pq;
//尾插数据
pq.push(1);
pq.push(2);
pq.push(6);
pq.push(2);
pq.push(3);
cout << "size=" << pq.size() << endl;
while (!pq.empty())
{
//取堆顶数据
cout << pq.top() << " ";
//删除堆顶元素
pq.pop();
}
cout << endl;
return 0;
}运行结果：
int main()
{
//给定比较方式为greater,创建小根堆
priority_queue<int, vector<int>,greater<int>> pq;
//尾插数据
pq.push(1);
pq.push(2);
pq.push(6);
pq.push(2);
pq.push(3);
cout << "size=" << pq.size() << endl;
while (!pq.empty())
{
//取堆顶数据
cout << pq.top() << " ";
//删除堆顶元素
pq.pop();
}
cout << endl;
return 0;
}运行结果：
priority_queue的模拟实现
基础接口
#include <iostream>
#include <vector>
template<class T, class Container = vector<T>>
class priority_queue
{
public:
//获取堆顶元素即数组首元素
const T& top()
{
return _con[0];
}
//获取堆的数据个数即容器中的数据个数
size_t size()
{
return _con.size();
}
//检测堆是否为空即容器是否为空
bool empty()
{
return _con.empty();
}
private:
Container _con;
};push()
堆的存储结构为数组，尾插时间复杂度O(1)，首先将元素插入到数组的尾部，其次利用堆的向上调整算法，将数组调整为大根堆/小根堆；
堆的向上调整算法
case 1:
当插入的数值M大于其父节点的值时，仍然为小堆，此时不做任何调整；
case 2:
当插入的数值M小于其父节点的值时，破坏了堆的逻辑结构，向上调整为小堆；
（假设M=5）
向上调整的过程中，只要出现待调整的孩子结点大于其父节点，便可停止调整，已经满足小堆的逻辑结构；
//向上调整为小堆
void adjustup(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 adjustup(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 push(const T& val)
{
//插入数据
_con.push_back(val);
//从插入值为val的孩子结点的下标开始向上调整为小堆/大堆
adjustup(_con.size()-1);
}pop()
堆的删除是删除堆顶数据，首先将堆顶元素与堆中最后一个元素交换，其次删除堆中最后一个元素，最后将堆顶元素利用向下调整算法调整到满足其逻辑结构为堆；
注：堆的向下调整算法的前提左右子树同为小堆/同为大堆；
堆的向下调整算法
case 1：左右子树皆为小堆，向下调整为小堆；
//向下调整为小堆
void adjustdown(size_t parent)
{
size_t child = 2 * parent + 1;
while (child < _con.size())
{
//假设法求同一层孩子节点最小者
if (child + 1 < _con.size() && _con[child] > _con[child + 1])
{
child++;
}
//逻辑关系不满足小堆，交换调整
if (_con[child] < _con[parent])
{
swap(_con[child], _con[parent]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}case 2：左右子树皆为大堆，向下调整为大堆；
//向下调整为大堆
void adjustdown(size_t parent)
{
size_t child = 2 * parent + 1;
while (child < _con.size())
{
//假设法求同一层孩子节点最大者
if (child + 1 < _con.size() && _con[child] < _con[child + 1])
{
child++;
}
//逻辑关系不满足大堆，交换调整
if (_con[child] > _con[parent])
{
swap(_con[child], _con[parent]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}堆的删除
void pop()
{
//将堆顶元素与堆中最后一个元素交换
swap(_con[0], _con[size() - 1]);
//删除最后一个元素
_con.pop_back();
//将堆顶元素利用向下调整算法调整到满足其逻辑结构为堆
adjustdown(0);
}priority_queue最终实现
堆分为大根堆与小根堆，向上调整算法/向下调整算法对于大根堆/小根堆的实现只有各别符号的差别，外部使用优先队列（priority_queue）时，只能在内部手动修改相应的符号来控制生成的是大堆/小堆，对于使用者而言，只能创建大堆/小堆，两者只能实现一个，故引入第三个模版参数传递仿函数类型，指定比较方式，此时使用者只需给定比较方式便可在大小堆之间自由切换；
注意：由于容器中一开始没有数据，故不用建堆，它是每插入一个数据，调用向上调整法，删除数据，调用向下调整法，不断地插入和删除，并且使其保持堆的逻辑结构 ；
#include <iostream>
#include <vector>
#include <functional>
using namespace std;
template<class T, class Container =vector<T>, class Compare = less<T>>
class priority_queue
{
public:
bool empty() const
{
return _con.empty();
}
size_t size() const
{
return _con.size();
}
const T& top() const
{
return _con[0];
}
T& top()
{
return _con[0];
}
//向上调整算法
void adjustup(size_t child)
{
size_t parent = (child - 1) / 2;
while (child > 0)
{
//_con[parent]<_con[child],父节点小于其孩子节点，交换向上调整--->大堆
if (_cmp(_con[parent], _con[child]))
{
swap(_con[parent], _con[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void push(const T& val)
{
_con.push_back(val);
adjustup(_con.size() - 1);
}
//向下调整算法
void adjustdown(size_t parent)
{
size_t child = parent * 2 + 1;
while (child <_con.size())
{
//child+1< _con.size()保证右孩子结点存在
//less<T> _cmp ---> _con[child]<_con[child+1]--->child++ --->挑选大的孩子结点
if (child + 1 < _con.size() && _cmp(_con[child], _con[child + 1]))
{
child++;
}
//_con[parent]<_con[child],父节点小于其孩子结点,交换向下调整---->大堆
if (_cmp(_con[parent], _con[child]))
{
swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void pop()
{
swap(_con[0], _con[_con.size()-1]);
_con.pop_back();
adjustdown(0);
}
private:
Container _con;
Compare _cmp;//less<T> _cmp;
};欢迎大家批评指正，博主会持续输出优质内容，谢谢大家观看，码字画图不易，希望大家给个一键三连支持~ 你的支持是我创作的不竭动力~
81
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
