泛型算法系列37:堆算法

#include <algorithm>
#include <vector>
#include <iostream>
#include <functional>

using namespace std;
template <class Type>
void print_elements( Type elem ) { cout << elem << " "; }
/************************************************************************/
/*                                                                      */
template<class _RanIt> inline
void my_Make_heap(_RanIt _First, _RanIt _Last)
{	// make nontrivial [_First, _Last) into a heap, using operator<
typedef iterator_traits<_RanIt>::difference_type _Diff;
typedef iterator_traits<_RanIt>::value_type _Ty;
_Diff _Bottom = _Last - _First;

for (_Diff _Hole = _Bottom / 2; 0 < _Hole; )
{	// reheap top half, bottom to top
--_Hole;
my_Adjust_heap(_First, _Hole, _Bottom,
_Ty(*(_First + _Hole)));
}
}

template<class _RanIt, class _Diff, class _Ty> inline
void my_Adjust_heap(_RanIt _First, _Diff _Hole, _Diff _Bottom, _Ty _Val)
{	// percolate _Hole to _Bottom, then push _Val, using operator<
_Diff _Top = _Hole;
_Diff _Idx = 2 * _Hole + 2;

for (; _Idx < _Bottom; _Idx = 2 * _Idx + 2)
{	// move _Hole down to larger child
if (_DEBUG_LT(*(_First + _Idx), *(_First + (_Idx - 1))))
--_Idx;
*(_First + _Hole) = *(_First + _Idx), _Hole = _Idx;
}

if (_Idx == _Bottom)
{	// only child at bottom, move _Hole down to it
*(_First + _Hole) = *(_First + (_Bottom - 1));
_Hole = _Bottom - 1;
}
std::_Push_heap(_First, _Hole, _Top, _Val);
}

template<class _RanIt, class _Diff, class _Ty> inline
void _Push_heap(_RanIt _First, _Diff _Hole, _Diff _Top, _Ty _Val)
{	// percolate _Hole to _Top or where _Val belongs, using operator<
for (_Diff _Idx = (_Hole - 1) / 2;
_Top < _Hole && _DEBUG_LT(*(_First + _Idx), _Val);
_Idx = (_Hole - 1) / 2)
{	// move _Hole up to parent
*(_First + _Hole) = *(_First + _Idx);
_Hole = _Idx;
}

*(_First + _Hole) = _Val;	// drop _Val into final hole
}

template<class _RanIt,
class _Ty> inline
void my_Pop_heap_0(_RanIt _First, _RanIt _Last, _Ty *)
{	// pop *_First to *(_Last - 1) and reheap, using operator<
_Pop_heap(_First, _Last - 1, _Last - 1,
_Ty(*(_Last - 1)), _Dist_type(_First));
}

template<class _RanIt> inline
void my_pop_heap(_RanIt _First, _RanIt _Last)
{	// pop *_First to *(_Last - 1) and reheap, using operator<
_DEBUG_RANGE(_First, _Last);
_DEBUG_HEAP(_First, _Last);
if (1 < _Last - _First)
my_Pop_heap_0(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Val_type(_First));
}

template<class _RanIt> inline
void my_Sort_heap(_RanIt _First, _RanIt _Last)
{	// order heap by repeatedly popping, using operator<
_DEBUG_RANGE(_First, _Last);
_DEBUG_HEAP(_First, _Last);
for (; 1 < _Last - _First; --_Last)
std::pop_heap(_First, _Last);
}
/************************************************************************/
int main()
{
int ia[] = {29,23,20,22,17,15,26,51,19,12,35,40 };
vector< int > vec( ia, ia + 12 );
// generates: 51 35 40 23 29 20 26 22 19 12 17 15
my_Make_heap( &ia[0], &ia[12] );
void (*pfi)( int ) = print_elements;
for_each( ia, ia + 12, pfi ); cout << "/n/n";
// generates: 12 17 15 19 23 20 26 51 22 29 35 40
// a min-heap: root is smallest element
make_heap( vec.begin(), vec.end(), greater<int>() );
for_each( vec.begin(), vec.end(), pfi ); cout << "/n/n";
// generates: 12 15 17 19 20 22 23 26 29 35 40 51
sort_heap( ia, ia + 12 );
for_each(  ia, ia + 12, pfi ); cout << "/n/n";
// add an additional, new smallest element:
vec.push_back( 8 );
// generates: 8 17 12 19 23 15 26 51 22 29 35 40 20
// should place newest smallest element at root
push_heap( vec.begin(), vec.end( ), greater<int>() );
for_each(  vec.begin(), vec.end(), pfi ); cout << "/n/n";
// generates: 12 17 15 19 23 20 26 51 22 29 35 40 8
// should replace smallest element with second smallest
pop_heap( vec.begin(), vec.end(), greater<int>() );
for_each( vec.begin(), vec.end(), pfi ); cout << "/n/n";

return 0;
}

1。概念：堆是一种特殊的二叉树，具备以下两种性质
1）每个节点的值都大于（或者都小于，称为最小堆）其子节点的值
2）树是完全平衡的，并且最后一层的树叶都在最左边
这样就定义了一个最大堆。

2。堆可以用一个数组表示，有如下性质：
heap[i]>=heap[2*i+1] 其中0<=i<=(n-1)/2
heap[i]>=heap[2*i+2] 其中0<=i<=(n-2)/2

3.

// push_heap为向堆中添加一个新的元素, 调用这个算法的前提是[First, Last)之间的元素满足堆的条件
// 新加入的元素为Last
void push_heap(int* pFirst, int* pLast);

// pop_heap为从堆中删除一个元素, 调用这个算法的前提是[First, Last)之间的元素满足堆的条件
// 被删除的元素被放置到Last - 1位置,由于这里是max-heap,所以被删除的元素是这个序列中最大的元素
void pop_heap(int* pFirst, int* pLast);

// make_heap将序列[First, Last)中的元素按照堆的性质进行重组
void make_heap(int* pFirst, int* pLast);

// 对堆进行排序, 调用这个函数可以成功排序的前提是[pFirst, pLast)中的元素符合堆的性质
void sort_heap(int* pFirst, int* pLast);