运用比较器实现机制(函数对象和指针对象)实现最大堆和最小堆
首先我们来了解一下最基本的函数对象的应用。
先来看STL源码：
//priority_queue模板源码：
template<class _Ty,
class _Container = vector<_Ty>,
class _Pr = less<typename _Container::value_type> >
class priority_queue
{ // priority queue implemented with a _Container
public:
explicit priority_queue(const _Pr& _Pred)
: c(), comp(_Pred)
{
//To use the comparator functor
//bool b = comp(t1, t2);
}
protected:
_Container c; // the underlying container
_Pr comp; // the comparator functor
};
可见_Pr为一种类型，可以为函数指针类型，也可以为类类型。
当为函数指针类型时，必须显式的传入对象，如：
typedef bool (*myfunc)(int , int);
bool testFuncPointer(int i, int j)
{
if (i < j)
return true;
return false;
}
priority_queue<int, myfunc> q(testFuncPointer);
当为类对象时，不需要传入，因为_Pr comp会初始化一个对象出来，继而调用该函数对象的()操作符。
如：
priority_queue<int, greater<int>> q;
但有的人说了：我非要传进去一个函数对象进去不可，这样写。
priority_queue<int> q(less<int>());
priority_queue<int> q(less<int>);错
此种情况为类模板，但是泛型函数，内部书写方式如下：
比如sort：
template<class _RanIt,
class _Diff,
class _Pr> inline
void _Sort(_RanIt _First, _RanIt _Last, _Diff _Ideal, _Pr _Pred)
{
//_Pred(t1, t2);
}
不再有如同上述模板类中的private成员的构造函数，所以_Pred必须传如对象
bool UDgreater ( int elem1, int elem2 )
{
return elem1 > elem2;
}
sort( v1.begin( ), v1.end( ), greater<int>( ) );
sort( v1.begin( ), v1.end( ), greater<int>);错
sort( v1.begin( ), v1.end( ), UDgreater );
另外，更多的函数对象技术，比如否定器，绑定器之类的，去看源代码理解吧。
Tags：Pred一元谓词，BinPred二元谓词，Cmp比较操作，Op一元操作，BinOp二元操作，bind2nd是一个函数，binder2nd是一个类模板等等等等。
附：模仿STL源码自己实现堆，依据传入的cmp去指明是最大堆还是最小堆。
//less是最小堆，即top()返回最小的一个
template<typename T, typename cmp=less<T>>
class MyHeap
{
public:
MyHeap(cmp _cmp = cmp());
MyHeap(T arr[], int len, cmp _cmp = cmp());
const T& top()const
{
assert(m_size > 0);
return m_data[0];
}
T &top()
{
assert(m_size > 0);
return m_data[0];
}
void pop();
int size()const{return m_size;}
void push(const T &val);
private:
void make_heap();
void fix_from_top(int root);
void _swap(T &a, T &b){T tmp = a; a = b; b = tmp;}
void fix_from_bottom(int child);
cmp m_cmp;
static const int MAXSIZE = 1024;
T m_data[MAXSIZE];
int m_size;
};
template<typename T, typename cmp>
MyHeap<T, cmp>::MyHeap(T arr[], int len, cmp _cmp)
:m_cmp(_cmp)
{
assert(len <= MAXSIZE);
memcpy(m_data, arr, sizeof(T)*len);
m_size = len;
make_heap();
}
template<typename T, typename cmp>
MyHeap<T, cmp>::MyHeap(cmp _cmp /* = less<T> */)
:m_size(0)
{
}
template<typename T, typename cmp>
void MyHeap<T, cmp>::make_heap()
{
int end = m_size-1;
for (int i = (end-1)/2; i >= 0; --i)
{
fix_from_top(i);
}
}
template<typename T, typename cmp>
void MyHeap<T, cmp>::fix_from_top(int root)
{
int range = m_size-1;
T val = m_data[root];
int father = root;
int son = father*2+1;
while (son <= range)
{
if(son + 1 <= range && !m_cmp(m_data[son], m_data[son+1]))
++ son;
if (!m_cmp(m_data[father], m_data[son]))
{
_swap(m_data[father], m_data[son]);
father = son;
son = father*2+1;
}
else
break;
}
}
template<typename T, typename cmp>
void MyHeap<T, cmp>::pop()
{
assert(m_size>0);
-- m_size;
m_data[0] = m_data[m_size];
fix_from_top(0);
}
template<typename T, typename cmp>
void MyHeap<T, cmp>::push(const T &val)
{
assert(m_size < MAXSIZE-1);
m_data[m_size] = val;
fix_from_bottom(m_size);
++ m_size;
}
template<typename T, typename cmp>
void MyHeap<T, cmp>::fix_from_bottom(int child)
{
T val = m_data[child];
int father = (child-1)/2;
while (father >= 0)
{
if (!m_cmp(m_data[father], m_data[child]))
{
_swap(m_data[father], m_data[child]);
child = father;
if (child > 0)
father = (child-1)/2;
else
father = -1;
}
else
break;
}
}