堆

简单堆的特点

1) 第一个点是根结点

2) 头指针指向根结点

3) 本质是一个树

4) 第 I 号节点的左儿子是第I * 2 号，右儿子是第I * 2 + 1号

5) 第I 层元素一定比第I + k ( k>0 ) 层优
堆的建立与维护

1) 每次入队一个元素(假设编号为k)

2) 将此入队元素与其父节点(编号(int)(k/2))进行对比

3) 若该元素最优，swap二者，进行2)
这称为上浮

堆的取出

1) 一般来说每次取堆顶的一个元素

2) 取得该元素后删除该元素

3) 删除堆顶元素的方法：拷贝队末元素至堆顶

4) 删除队末元素所占空间

5) 把堆顶元素下沉
下沉操作

1) 将该元素与其子节点(编号(int)(k*2)与(int)(k*2+1))进行比较

2) 若该元素非最优，swap二者，进行1)

下面是代码，小根堆的
# include <iostream>
# include <fstream>
# include <cstdio>
# include <cstdlib>
# include <cstring>
# include <cmath>
# include <algorithm>
# include <vector>
# include <deque>
# include <list>

using namespace std ;

template <class type>
class tree
{
public :
deque <type> q ;
tree () ;
void get ( type ) ;
void down_load ( int ) ;
void up_date ( int ) ;
void swap ( int , int ) ;
void print () ;
private :
int size ;
} ;

tree <int> t ;
int temp;
void work () ;
int main ()
{
freopen ( "堆.in"  , "r" , stdin  ) ;
freopen ( "堆.out" , "w" , stdout ) ;
work () ;
}
void work ()
{
while ( cin >> temp )
{
t.get ( temp ) ;
t.print () ;
}
}

template <class type>
void  tree <type>::get ( type the )
{
size ++ ;
cout << "got " << the << '\n' ;
this->q.push_back ( the ) ;
up_date ( this->size ) ;
cout << '\n' ;
return ;
}
template <class type>
void tree <type>::up_date ( int the )
{
while (  the / 2 != 0 && q[ the ] > q[ the / 2 ] )
{
        cout << "up_date " << q[ the ] << "  " << q[ the / 2 ] << '\n' ;
        cout << "        " << the << "  " << the / 2 << '\n' ;
swap ( the , the / 2 ) ;
the /= 2 ;
}
return ;
}
template <class type>
void tree <type>::down_load ( int the )
{
while ( the * 2 <= q.size () && q[ the ] < q[ the  * 2 ]
||  the * 2 + 1 <= q.size () && q[ the ] < q[ the * 2 + 1 ] )
{
if ( the * 2 <= q.size () && q[ the ] < q[ the  * 2 ] )
{
swap ( the , the * 2 ) ;
the *= 2 ;
}
            if ( the * 2 + 1 <= q.size () && q[ the ] < q[ the * 2 + 1 ] )
{
swap ( the , the * 2 + 1 ) ;
the = the * 2 + 1 ;
}
}
}
template <class type>
void tree <type>::swap ( int a , int b )
{
cout << "swap  " << q[ a ] << " of " << q[ b ] << '\n' ;
type c = q[ a ] ;
q[ a ] = q[ b ] ;
q[ b ] = c ;
return ;
}
template <class type>
tree <type>::tree ()
{
q.push_back ( 0 ) ;
size = 0 ;
return ;
}
template <class type>
void tree <type>::print ()
{
int _matrix_2 = 1 , ii = 1 , jj = 1 , kk = 1 ;
while ( ii <= size )
{
for( jj = ii ; jj <= size && jj<= ii + kk - 1 ; jj ++ )
cout << q[ jj ] << "(" << q[ jj / 2 ] << ") " ;
ii = jj ;
kk *= 2 ;
cout << '\n' ;
}
}

加了判定函数以后的模板是这样
# include <iostream>
# include <fstream>
# include <cstdio>
# include <cstdlib>
# include <cstring>
# include <cmath>
# include <algorithm>
# include <vector>
# include <deque>
# include <list>

using namespace std ;

template <class type>
class tree
{
public :
deque <type> q ;
tree () ;
void get ( type ) ;
void down_load ( int , bool ( * )( const type& , const type& ) ) ;
void up_date ( int , bool ( * )( const type& , const type& ) ) ;
void swap ( int , int ) ;
void print () ;
private :
int size ;
} ;

tree <int> t ;
bool cmp ( const int& , const int& ) ;
int temp;
void work () ;
int main ()
{
freopen ( "堆.in"  , "r" , stdin  ) ;
freopen ( "堆.out" , "w" , stdout ) ;
work () ;
}
void work ()
{
while ( cin >> temp )
{
t.get ( temp ) ;
t.print () ;
}
}

template <class type>
void  tree <type>::get ( type the )
{
size ++ ;
this->q.push_back ( the ) ;
up_date ( this->size , cmp ) ;
return ;
}
bool cmp ( const int &aa , const int &bb )
{
return aa > bb ;
}
template <class type>
void tree <type>::up_date ( int the , bool ( *pp )( const type& , const type& ) )
{
while (  the / 2 != 0 && ( *pp )( q[ the ] , q[ the / 2 ] ) )
{
swap ( the , the / 2 ) ;
the /= 2 ;
}
return ;
}
template <class type>
void tree <type>::down_load ( int the , bool ( *pp )( const type& , const type& ) )
{
while ( the * 2 <= q.size () && ( ! ( *pp )( q[ the ] , q[ the  * 2 ] ) )
||  the * 2 + 1 <= q.size () && ( ! ( *pp )( q[ the ] , q[ the * 2 + 1 ] ) ) )
{
if ( the * 2 <= q.size () && ( ! ( *pp )( q[ the * 2 ] , q[ the ] ) ) )
{
swap ( the , the * 2 ) ;
the *= 2 ;
}
else
{
swap ( the , the * 2 + 1 ) ;
the = the * 2 + 1 ;
}
}
}
template <class type>
void tree <type>::swap ( int a , int b )
{
type c = q[ a ] ;
q[ a ] = q[ b ] ;
q[ b ] = c ;
return ;
}
template <class type>
tree <type>::tree ()
{
q.push_back ( 0 ) ;
size = 0 ;
return ;
}
template <class type>
void tree <type>::print ()
{
int _matrix_2 = 1 , ii = 1 , jj = 1 , kk = 1 ;
while ( ii <= size )
{
for( jj = ii ; jj <= size && jj<= ii + kk - 1 ; jj ++ )
cout << q[ jj ] << "(" << q[ jj / 2 ] << ") " ;
ii = jj ;
kk *= 2 ;
cout << '\n' ;
}
}