探究STL 优先队列的自定义比较方式与 sort() 等泛型算法的自定义比较方式的区别

前言

---

　　

　　最近在刷算法题，经常须要自定义比较函数做为做为函数对象送入 stl 中，遇到了下面的问题：

　　 泛型算法 sort() 实现从小到大的递增关系是这么写： 

//sort 函数的模板声明 // 能够看出，排序要求容器支持随机访问迭代器，相似于数组的那种下标偏移访问 // 这里 _Compare 是类型， __comp 是实例，调用 sort 须要传入的就是 __comp 实例
template <class _RandomAccessIter, class _Compare> inline void sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp) //利用priority_queue 实现元素间关系为递增(实现最小堆) 的方法以下： //自定义比较函数，排序时传入函数指针，编译器会进行类型推导作模板特化 
bool cmp (const T& a, const T& b) { return a.x < b.x; } //对于自定义结构体，可重载 < 运算符，排序时会默认调用 operator < 
struct T{ friend bool operator < (const T& a) { return this.x < a.x; } };

 

 

　　而优先队列里是这么写：

// priority_queue 实现使用的默认比较是 operator< ,是最大堆数据结构，即队列头元素值最大
template <class _Tp, class _Sequence __STL_DEPENDENT_DEFAULT_TMPL(vector<_Tp>), class _Compare __STL_DEPENDENT_DEFAULT_TMPL(less<typename _Sequence::value_type>) class priority_queue;  // 注意点：若是传入本身的仿函数，那么第二个存储类型也要传入
 //利用priority_queue 实现元素间关系为递增(实现最小堆) 的方法以下： //仿函数
struct cmp {　　 bool operator () (const T& a, const T& b) const { return a.x > b.x; } } //自定义结构体中重载 < 
struct T { Type_2 x; friend bool operator < (const T&a, const T& b)  { return a.x > b.x; } }

 

　　一样是实现元素的递增关系即 “前一元素的x份量 < 后一元素的x份量”，为何前一个是 “a.x < b.x”，然后一个是"a.x > b.x" 呢？

 

分析 sort() 

---

 

　　先拿 sort() 进行分析，排序类的泛型算法不少，它们的 cmp 写法是类似的，这里先看一份冒泡排序实现递增关系如 <1, 2, 3 ..> 的写法，传入的 cmp 将特化为 Compare 实例 comp ，使得容器中的相邻元素按 cmp 中的逻辑进行排序。

#include <iostream> template <class BidirectionalIt, class Compare> //双向迭代器
void bubble_sort(BidirectionalIt first, BidirectionalIt last, Compare comp) { for (; first != last; --last) for (BidirectionalIt current = first, next = first; ++next != last; ++current) if (!comp(*current, *next)) std::swap(*current, *next); } }
bool cmp (int a, int b){ return a < b; } 

　　一言以蔽之，就是元素将按照 cmp 中定义的逻辑关系进行排列。

　　虽然 sort() 是用“快排+堆排+插入”实现的而并不是冒泡，可是原理是同样的。

 

分析 priority_queue 

---

　　

　　如今咱们再来看看优先队列。

　　STL优先队列模板：priority_queue<Type, Container, Functional> ，参数分别对应的是“元素类型”、“容器类型”、“比较函数”。

　　注意，优先队列不是 STL 的容器，而是由 底层容器 vector/deque 实现的模板类，缺省状况下它利用 MAX-HEAP 实现，而 MAX-HEAP 是 vector 实现的彻底二叉树，这样的东西称为适配器 (adapter)。

　　在优先队列中默认优先级高的元素先出队列，具体操做是使用函数对象 less<> 重载了 “<”，因此这里优先级的高低是由 “<” 肯定的，因此当咱们按下面的形式写：

priority_queue<int> pQueue;

　　经过操做符 < 知道元素关键字大的优先级高，此时是最大堆。若每次从堆顶取一个元素，最后获得一个序列，那么序列中元素的关系是递减的。

　　咱们想要让元素的关系是递增该怎么作？

 　　第一种办法：使用与 less<>做用相反的函数对象 greater<> 。

　　　　ex：以下

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

　　

　　第二种办法：在自定义结构体中重载  < ，经过它实现对自定义数据类型的优先级的定义。

　　　　ex：经过重载 operator < 操做符以比较元素的优先级

struct T{ DataType key; friend bool operator < (const T& a, const T& b) { return a.key > b.key; } };

　　　　逻辑是这样：假设 a.key > b.key 为 TRUE ，因为默认是最大堆，此时优先队列会认为 a < b ，即 b 的优先级比 a 高，因此 b会被先出队，这样就实现了关键字小的元素先出队。最后输出的序列是按关键字递增的。

　　　　但此时不能像基本类型这样声明 ：priority_queue<T, vector<T>, greater<T> > (注意空格);

　　　　而是只能这样声明：priority_queue<T>

　　　　缘由是 greater<T> 没有定义，若是想用这种方法定义，则使用方法3。

　　　　注意，这种办法有缺点，若是有两个模板容器对同一个自定义数据结构须要不一样的比较器，那么办法就不如函数对象适用了。

　　

　　第三种办法：经过函数对象以定义元素的优先级。

　　ex：以下

struct T { int x; T(int xx) : x(xx) {} }; struct cmp{ bool operator () (const T& a, const T& b) const
　　{ return a.x > b.x; } };

　　　　逻辑和 2 是同样的。这里重载了 () 的目的是使得 cmp 成为像 less<> 同样的函数对象，做为新的比较比较级的规则以 priority_queue 第三个参数的形式传入 priority_queue 中。

　　　

总结

---

 

　　优先队列的“比较级”概念与”由MAX-HEAP实现“这一特性，使得自定义比较函数中须要这么写： "a.x>b.x" 。

 

延伸阅读

---

 

　　永远让比较函数对相等的值返回false(来自Effective C++)

　　C++中的 sort 使用自定义比较函数的具体运行过程是怎样的呢？

　　C++自定义比较：仿函数、函数与重载运算符