MinHeap

#i n c l u d e <i o s t r e a m >
#i n c l u d e <v e c t o r >
#i n c l u d e < l i m i t s . h>
u s i n g namespace s t d ;
t e m p l a t e < c l a s s T>
c l a s s MinHeap{
public :
v e c t o r <T> e l e m e n t o s ;
MinHeap ( ) {}
void insert_key ( i n t k ) ;
i n t p a r e n t ( i n t i ) { r e t u r n ( i 1) / 2 ; }
i n t l e f t ( i n t i ) { r e t u r n (2 i +1) ; }
i n t r i g h t ( i n t i ) { r e t u r n (2 i +2) ; }
i n t getMin ( ) {
i f ( e l e m e n t o s . s i z e ( ) ==0){
cout<<" El heap no t i e n e minimo e l e m e n t o \n" ;
r e t u r n INT_MAX;
}
else {
i n t p=e l e m e n t o s . data ( ) ;
return p [ 0 ] ;
}
}
v o i d MinHeapify ( i n t i ) ;
i n t extract_min ( ) ;
v o i d d e c r e a s e K e y ( i n t i n d i c e , i n t new_val ) ;
void print ( ) ;
};
template <c l a s s T>
v o i d MinHeap<T> : : i n s e r t _ k e y ( i n t k ) {
e l e m e n t o s . push_back ( k ) ;
i n t i=e l e m e n t o s . s i z e ( ) 1;
i n t p=e l e m e n t o s . data ( ) ;
w h i l e ( i !=0 && p [ p a r e n t ( i ) ]>p [ i ] ) {
swap ( p [ i ] , p [ p a r e n t ( i ) ] ) ;
i=p a r e n t ( i ) ;
}

}
template <c l a s s T>
v o i d MinHeap<T> : : d e c r e a s e K e y ( i n t i n d i c e , i n t new_val ) {
i n t p=e l e m e n t o s . data ( ) ;
i n t temp=p [ i n d i c e ] ;
i f ( temp<new_val ) {
p [ i n d i c e ]=new_val ;
w h i l e ( i n d i c e !=0&&p [ p a r e n t ( i n d i c e ) ]>p [ i n d i c e ] )
{

swap ( p [ i n d i c e ] , p [ p a r e n t ( i n d i c e ) ] ) ;
i n d i c e=p a r e n t ( i n d i c e ) ;

}
}
t e m p l a t e < c l a s s T>
v o i d MinHeap<T> : : MinHeapify ( i n t i ) {
i n t p=e l e m e n t o s . data ( ) ;
i n t i z q= l e f t ( i ) ;
i n t d e r=r i g h t ( i ) ;
i n t _min=i ;
i f ( i z q <e l e m e n t o s . s i z e ( ) &&(p [ i z q ]<p [ i ] ) ) {
_min=i z q ;
}
i f ( der<e l e m e n t o s . s i z e ( ) &&(p [ d e r ]<p [ _min ] ) ) {
_min=d e r ;
}
i f (_min!= i ) {
swap ( p [ i ] , p [ _min ] ) ;
MinHeapify (_min) ;
}
}

t e m p l a t e < c l a s s T>
i n t MinHeap<T> : : extract_min ( ) {
i f ( e l e m e n t o s . s i z e ( ) ==0){

c e r r <<"No hay e l e m e n t o s en e l heap \n" ;

r e t u r n INT_MAX;
}
e l s e i f ( e l e m e n t o s . s i z e ( ) ==1){
i n t p = e l e m e n t o s . data ( ) ;
return p [ 0 ] ;
}
i n t p=e l e m e n t o s . data ( ) ;
i n t r o o t=p [ 0 ] ;
p [ 0 ] = p [ e l e m e n t o s . s i z e ( ) 1];
e l e m e n t o s . r e s i z e ( e l e m e n t o s . s i z e ( ) 1) ;
MinHeapify ( 0 ) ;
return root ;

}
t e m p l a t e < c l a s s T>
v o i d MinHeap<T> : : p r i n t ( ) {
v e c t o r <i n t > : : i t e r a t o r i t ;
i t = elementos . begin () ;
f o r ( i t=e l e m e n t o s . b e g i n ( ) ; i t <e l e m e n t o s . end ( ) ; i t ++)
c o u t << ' '<< i t ;
cout<<e n d l ;
}
i n t main ( )
{
c o u t << " H e l l o world ! " << e n d l ;
MinHeap<i n t > h ;
h . insert_key (6) ;
h . insert_key (7) ;
h . insert_key (8) ;
h . insert_key (9) ;
h . insert_key (10) ;
h . insert_key (11) ;
h . print () ;
cout<<h . extract_min ( ) ;
cout<<e n d l ;
h . print () ;
/ c o u t <<e n d l ;

c o u t <<h . g e t M i n ( ) ; /
/ i n t

h e a p _ s i z e =0;

v e c t o r <i n t > numeros ;

numeros . push_back ( 5 ) ;
numeros . push_back ( 3 ) ;
v e c t o r <i n t > : : i t e r a t o r
int

it ;

p = numeros . d a t a ( ) ;

c o u t <<p [1]<< e n d l ; /
/
i t =numeros . b e g i n ( ) ;
it

= numeros . i n s e r t

it

100

);

it

= numeros . i n s e r t

it

200

) ; /

/ i t
for
cout

= numeros . b e g i n ( ) ;
( i t =numeros . b e g i n ( ) ;
<<' '<<

i t <numeros . end ( ) ;

i t ; /

// c o u t <<numeros [ 0 ] ;
// numeros . r e s i z e ( numeros . s i z e ( )
// c o u t <<numeros . s i z e ( ) ;

return 0;

2) ;

i t ++)