HEAP

Estructuras de Datos
FIEC03012

Estructuras de Datos
© ESPOL 1
2016-1T
CONCEPTOS
 Arbol Binario Completo
 Todos sus niveles n-1 estan llenos
 A excepción del ultimo nivel,
 Alli las hojas van apareciendo
seguidas de izquierda a derecha

150

125 75 • Arbol Parcialmente Ordenado

• Todas y cada una de sus ramas están
80 30 25 72
totalmente ordenadas
15 20 28 • Entre raiz e hijos, la raiz contiene el
mayor(o menor) de todos
Estructuras de Datos
© ESPOL 2
2016-1T
HEAP
• Heap (montículo) es un árbol binario completo y además
parcialmente ordenado, representado como un arreglo.
• Heap presenta un cierto orden
• Al remover consecutivamente la raiz
• Vamos consiguiendo valores ordenados

• El heap se utiliza
• Para el ordenamiento de elementos(HeapSort)
• Para implementar colas de prioridad
• QDesencolarMax, es retirar el valor de la raiz
Estructuras de Datos
© ESPOL 3
2016-1T
 1

IMPLEMENTACION 2 150 3

125 75
4 5 6 7

80 30 25 72
• Un heap no admite “huecos”,
• C/nivel se va llenando de izq. A der
15 20 28
• Hay una secuencia i/2
8 9 10
• Podriamos numerar c/nodo
• En el orden de llenado

 Si lo vemos asi, dado un índice i*2 i*2+1

 Podemos conocer los indices de los hijos
y el padre de un nodo
 Ejemplo: Del nodo 4, hijos 8 y 9, padre 2

Estructuras de Datos
© ESPOL 4
2016-1T
CONTANDO DESDE 0 0

• Queremos usar un Arreglo 1 150 2

• En c/elemento almacenar la información 125 75

3 4 5 6
• Dirigirnos a hijos y padre calculando el
índice respectivo 80 30 25 72

15 20 28

 Los vectores empiezan desde 0 7 8 9

 Cambia un poquito la regla

150 125 75 80 30 25 72 15 20 28
 Izq(i) = (i+1)*2-1 = i*2+1
0 1 2 3 4 5 6 7 8 9
 Der(i) = (i+1)*2 = i*2+2
 Padre(i) = (i+1)/2-1 = (i-1)/2

Estructuras de Datos
© ESPOL 5
2016-1T
REGLAS
•Arreglo A de tamaño efectivo n 0

1 150 2
• A[0] es la raiz
125 75
• Dado un nodo A[i] 3 4 5 6

80 30 25 72
• Si 2i+1 < n, A[2i+1] es el hijo izq
• Si 2i+2 < n, A[2i+2] es el hijo der 15 20 28
• Si i != 0, A[(i-1)/2] es el padre 7 8 9

150 125 75 80 30 25 72 15 20 28
0 1 2 3 4 5 6 7 8 9

Estructuras de Datos
© ESPOL 6
2016-1T
DECLARACION: TDA HEAP

• Tipo de Dato class Heap<T>{

• Necesitamos un arreglo T elementos[MAX];
• Llevar el tamaño efectivo int nEfectivo;
• Llevar el máximo del arreglo int MAX;
• Sabber el orden (asc – desc) int tipoOrden;
}

Estructuras de Datos
© ESPOL 7
2016-1T
OPERACIONES BASICAS: TDA HEAP
• Desencolar y Encolar
• Desencolar: Extraer el elemento mas grande/pequeño del heap(la raiz)
• Encolar: Insertar un valor al heap y ubicarlo en la posicion correcta
• HeapSort
• Dado un Heap permite generar un arreglo/lista ordenado
• Operaciones Adicionales
• Ajustar
• Reestablece la propiedad de orden de un subheap hacia abajo
• No a todo el arbol!
• Construir_heap
• Dado un arreglo que no representa un heap
• ardena el arreglo y lo convierte en un Heap
Estructuras de Datos
© ESPOL 8
2016-1T
 MAS OPERACIONES
• int posIzq(int i);  public Heap(int tmax, TipoOrden t);

• Retorna el indice del nodo izq de i  Constructor de un heap, inicializa para tener un

tamaño maximo tmax y un orden t(ascendente o

• Si no cumple las reglas, retorna -1
descendente)
• int posDer(int i);
 bool estaVacio();
• Retorna el índice del nodo der de i
 Recibe un Heap y determina si esta Vacio
• Si no cumple las reglas, retorna -1

• int posPadre(int i);

• Retorna el índice del nodo padre de i

• Si no cumple las reglas, retorna -1

Estructuras de Datos
© ESPOL 9
2016-1T
AJUSTAR
• Recobra la propiedad de orden
• Desde un nodo de índice pos
• Dado un índice pos, PosIzq y PosDer
• Se compararan los tres para ver quien tiene el mayor
• Si el mayor lo tiene algun hijo
• Intercambia
• Al hacer esto, el sub-heap afectado puede perder su propiedad de Orden….
• Ajustar el sub-heap afectado

Estructuras de Datos
© ESPOL 10
2016-1T
AJUSTAR: EJEMPLO
0
• Un heap puede perder su orden
Pos 1 150 2

80
60 75  Ejemplo:
3 4 5 6  Ejemplo:
Pos
PosMayor En el
 No
 En el nodo
se nodo
puede31 no
no se
se cumple
ajustarcumple
un nodo hoja
80
60
70 30 25 72
Ajustar
 Ajustar

El mayor
El
 mayor es
es elel nodo
nodo 33
20 70
70
60 28 Intercambiar
Intercambiar

PosMayor Ajustar Otra
Ajustar
 desde nodo intercambiado(3)
Vez
7 8 9

150 80
60 75 80
70 30 25 72 20 70
60 28
0 1 2 3 4 5 6 7 8 9

Estructuras de Datos
© ESPOL 11
2016-1T
 AJUSTAR: IMPLEMENTACION
static void ajustar(int posnodo ){
int pos_mayor, izq, der;
pos_mayor = posnodo;
izq = posnodo*2+1;
der = posnodo*2+2;

if(izq>=0 && izq<= this.nEfectivo && this.elementos[izq].compareTo(this.elementos[posnodo]) >0)

pos_mayor = izq;
if(der>=0 && der<= this.nEfectivo && this.elementos[der].compareTo(this.elementos[pos_mayor])>0)
pos_mayor = der;
if(pos_mayor != posnodo){
intercambiar(posnodo,pos_mayor));
ajustar(pos_mayor);
}
}

Estructuras de Datos
© ESPOL 12
2016-1T
CONSTRUIR UN HEAP
• La estructura de un heap
• Puede almacenar un arreglo que no cumpla las propiedades de
orden
15 1 28 35 10 5 8 21 50 42
• Ejemplo:
0 1 2 3 4 5 6 7 8 9
0
 Hay que arreglar la propiedad
1 15 2
de orden
1 28
 De cada raiz 3 4 5 6

 Ajustar c/raiz
35 10 5 8
 Desde la ultima a la primera

21 50 42

7 8 9

Estructuras de Datos
© ESPOL 13
2016-1T
CONSTRUIR HEAP: EJEMPLO
15
50 42
1 28 35 10
15 5 8 21 50
1 42
10
3 7 8 9
• Ajustar el ultimo nodo raiz 0 1 2 4 5 6

0
• Los nodos raiz comienzan desde
1 50
15 2
0 hasta (n-1)/2
50
42
15
1 28
• Al ajustar cada nodo 3 4 5 6

• De atrás hacia delante 50

35
1 10
42
15 5 8

• Nos aseguramos que los valores

21 50
35
1 42
10
mas altos suban!
7 8 9

Estructuras de Datos
© ESPOL 14
2016-1T
CONSTRUIR HEAP:
IMPLEMENTACION
void makeHeap(){
int i;
for(i = (this.nEfectivo-1)/2; i >= 0; i--){
ajustar(i);
}
}

Estructuras de Datos
© ESPOL 15
2016-1T
DESENCOLAR
• Que importancia tiene la raiz en el heap?
• Es el mayor/menor elemento del mismo
• Sobre el resto de elementos no estamos seguros
• Pero de la raiz, es la mayor de todos
• Desencolar es eliminar la raiz
• Que valor se ubica en la nueva raiz?
• El ultimo reemplaza al primero
• El tamaño efectivo del heap cambia
• Se ajusta desde la raiz
• El arbol queda bien otra vez

Estructuras de Datos
© ESPOL 16
2016-1T
DESENCOLAR: EJEMPLO
0

• Intercambiar valores 1 150

125
28 2

80
28
125 75
• Raiz con ultimo 3 4 5 6

28
80 30 25 72
• Aminorar tamaño
efectivo 15 20 28

• Ajustar arbol desde raiz 7 8 9

150
125
28 125
80 75 80
28 30 25 72 15 20 28
0 1 2 3 4 5 6 7 8 9

Estructuras de Datos
© ESPOL 17
2016-1T
DESENCOLAR: IMPLEMENTACION
T Dequeue (){
T max;
if(!isEmpty(H)){
max = this.elementos[0];
intercambiar(0,this.nEfectiva-1);
this.nEfectiva --;
ajustar(0);
return max;
}
return null;
}
Estructuras de Datos
© ESPOL 18
2016-1T
ENCOLAR
•Al añadir un nuevo elemento el Heap
• DEBE conservar su propiedad de orden
•Se añade al final del arreglo
•El elemento empieza a subir a su posición ideal
• Comparando siempre con el padre
• Hasta que el valor insertado sea menor que el del
padre

Estructuras de Datos
© ESPOL 19
2016-1T
ENCOLAR: EJEMPLO
0

1 150 2
• Insertar al final
125
130 75
• Subir el valor hasta que ya 3 4 5 6

no sea necesario 80 30
130
125 25 72

15 20 28 30
130

7 8 9

Nuevo valor: 130 150 125

130 75 80 125
30 25 72 15 20 28 130
30
0 1 2 3 4 5 6 7 8 9 10

Estructuras de Datos
© ESPOL 20
2016-1T
ENCOLAR: IMPLEMENTACION

Estructuras de Datos
© ESPOL 21
2016-1T
HEAPSORT
•Uno de los usos de los heaps es ordenar
•Como?
• Extraer el mayor elemento del heap(raiz)
• Ponerla al final de otro arreglo
• Repetir los dos ultimos pasos hasta que el Heap
quede Vacio
•El arreglo quedara ordenado

Estructuras de Datos
© ESPOL 22
2016-1T
HEAPSORT: EJEMPLO 0

1 125
28
15
20
75
72
30
25
28
80
150 2

125
30
28
20
15
80 75
72
25
15
• Desencolar y ponerlo al 3 4 5 6

final del nuevo 28

15
80 30
20 25
15 72
15

arreglo/lista
15 20 28
• Repetir hasta que el 7 8 9

arbol quede vacio 150

125
80 125
75
72
30
28
25
20
15 80 15
30
28
20
15 75
72
25 80
28
15 30
20 25
15 72
15 15 20 28
0 1 2 3 4 5 6 7 8 9

15 20 25 28 30 72 75 80 125 150
0 1 2 3 4 5 6 7 8 9

Estructuras de Datos
© ESPOL 23
2016-1T
HEAPSORT: IMPLEMENTACION

T[] Heapsort (){

T lista [this.nEfectivo];
int i = this.nEfectivo;
while(!isEmpty(H)){
lista[this.nEfectivo-1] = Dequeue ()
}
return lista;
}

Estructuras de Datos
© ESPOL 24
2016-1T
CODIGOS DE HUFFMAN
Estructuras de Datos
FIEC03012

Estructuras de Datos
© ESPOL 25
2016-1T
CODIFICACION
• Codificar un texto
• Reemplazar con códigos por seguridad o ahorrar espacio
• Para obtener el texto original
• Se debe decodificar
• En el envío de información es muy popular
• Para ocular la información y volver el envio mas seguro

Estructuras de Datos
© ESPOL 26
2016-1T
UNA FORMA
• Codigos binarios
• Que represente cada letra del alfabeto.
• Si el alfabeto esta conformado por
• A, B, C, y D
• Podemos codificar cada letra con
• 010, 100, 000, 111
• La cadena ABACCDA quedaria
• 010100010000000111010

Estructuras de Datos
© ESPOL 27
2016-1T
ANALIZANDO
•Ventajas
• Es muy facil codificar y decodificar
• Solo reemplazar
• Cada código tiene la misma longitud
•Desventajas
• La cadena resultante es muy larga comparada con
el mensaje
•Como se podra reducir la cadena codificada?

Estructuras de Datos
© ESPOL 28
2016-1T
MEJORAR LA CODIFICACION
• A es la letra que mas se repite en el mensaje,
• Debería tener un código pequeño(menos espacio)
• La letra que menos aparece
• Puede tener un codigo mas grande
• El código de cada letra
• Puede depender de la frecuencia de la letra en la cadena
• O del idioma

• Códigos de Huffman
• códigos de longitud variable para codificar un determinado
símbolo basándose en la probabilidad estimada de aparición de
cada posible valor de dicho símbolo

Estructuras de Datos
© ESPOL 29
2016-1T
UN EJEMPLO
•A, B, C, D
•Se le puede asignar 0, 110, 10, 111
•Entonces ABACCDA es 011001010111
• Ya!, mas pequeña

Estructuras de Datos
© ESPOL 30
2016-1T
DECODIFICANDO

011001010111 A 0
B 110
Puede
Puede ser
Puede ser
ser
ser
C 10 Puede
A ? ?B A ?C C ??D B,BCC
B, o DD
B ooo
CD
D 111

Para decodificar hay que

elegir. El valor del codigo
depende del valor siguiente:
1 o 0, binario
Estructuras de Datos
© ESPOL 31
2016-1T
 A 0
DECODIFICANDO
B 110
011001010111
C 10
• Para decodificar
• Escoger primer bit D 111
• Determinar código entre ABCD
 Si es 0, es la letra A
 Si no, la letra podria ser BCD ABCD
 Escoger siguiente bit
 Determinar codigo entre BCD
 Si es 0: C
A(0) B C D(1)
 Si no, Determinar codigo entre BD
 Escoger siguiente bit C(0) B D(1)
 Determinar codigo entre BD
 Si es 0: B B(0) D(1)
 Si no, es D

Estructuras de Datos
© ESPOL 32
2016-1T
 Una vez construido el
arbol, obtendremos los
codigos de c/letra
CONSTRUIR EL ARBOL
A 3
• Necesitamos la frecuencia de cada Ej: ABACCDA
B 1
letra en la cadena
C 2
 Notemos que c/letra es una hoja D 1
A B C D
3 1 2 1
 Empecemos con las dos letras de menor frecuencia ACBD 7
 Se unen y crean un nuevo simbolo
 La frecuencia del nuevo es la suma de los dos ant. A(0) CBD(1)
CBD 4
 Se desechan los dos anteriores
3
 El grupo de letras se vuelve mas pequeño
C(0) BD 2
BD(1)
 Todo se repite hasta que no queden mas letras ind.
2
B(0) D(1)
Estructuras de Datos 1 1
© ESPOL 33
2016-1T
CONSEGUIR LOS CODIGOS
• Es una busqueda binaria
ACBD 7 • Los codigos se van acumulando a medida
que se busca la letra
A(0) CBD(1)
CBD 4 • Las letras siempre son hojas
3 • Si letra buscada esta
C(0) BD(1) 2 • En el subarbol izquierdo, se acumula un 0 o
2 • En el subarbol derecho, se acumula un 1
B(0) D(1)
1 1
A 0
B 110
11
1
C 10
1
D 1
111
11

Estructuras de Datos
© ESPOL 34
2016-1T
DECIDIENDO QUE USAR
 Primero, se construyen hojas para
A B C D
c/letra
3 1 2 1
 Para facilitar la ubicación de un nodo hoja al crear codigos
 Estos son almacenados a una cola de Prioridad

• Los nodos con menor frecuencia

• Salen primero
• Se unen, se crea un nuevo nodo
• Este se vuelve a ubicar en el listado de letras
• Cola de Prioridad, prioridad: la frecuencia

Estructuras de Datos
© ESPOL 35
2016-1T
DECLARACION DE TDA: ARBOL E INFO
Cada Nodo tendra Info, sub. Iza. Y Cada elemento del nodo tiene: una
subarbol der: cadena, frecuencia y un bit
Es ideal agrupar toda esta
informacion en un nuevo tipo de dato
public class NodoAB {
Info info; public class Info {
NodoAB izq, der; String Cadena;
} int frecuencia;
int bit;
}

Estructuras de Datos
© ESPOL 36
2016-1T
LA COLA DE PRIORIDAD
La cola de Prioridad almacenará nodos de Arbol.
Se la puede implementar como una lista ordenada o un arreglo
Si fuese lista, cada nodo seria NodoAB y la cola:

public class ColaDePrioridad {

Lista<NodoAB> listaOrdenada;
}

Estructuras de Datos
© ESPOL 37
2016-1T
 IMPLENTACION: CONSTRUIR ARBOL
public NodoAB construirArbolHuffman(String[] cadenas, int[] frecuencias) {
ColaPrioridad cola = new ColaPrioridad();
for (int i=0; i<cadenas.size(); i++) {
NodoAB nodo = new NodoAB(new Info(cadenas[i], frecuencias[i]));
cola.encolar(info);
}
while(cola.size() > 1) {
NodoAB izq = cola.desencolar();
NodoAB der = cola.desencolar();
izq.getInfo().setBit(0);
der.getInfo().setBit(1);
String cadenacomb = izq.getInfo().getCadena() + der.getInfo().getCadena();
int freqcomb = izq.getInfo().getFrecuencia()+der.getInfo().getFrecuencia();
NodoAB tmp = new NodoAB(new Info(cadenacomb, freqcomb));
tmp.setIzquierdo(izq);
tmp.setDerecho(der);
cola.encolar(tmp);
}
return cola.desencolar();
}
Estructuras de Datos
© ESPOL 38
2016-1T
IMPLEMENTACION: ASIGNAR CODIGOS
public String codificarCadena(String cadena, NodoAB arbol){
String codigo="";
NodoAB p = arbol;
while(!p.esHoja() && !p.estaVacio()){
NodoAB izq = p.getIzquierdo();
NodoAB der = p.getDerecho();

if(encontrarCadena(izq.getInfo().getCadena(), cadena)){
codigo += izq.getInfo().getBit();
p = izq;
}
else if(encontrarCadena(der.getInfo().getCadena(), cadena){
codigo += izq.getInfo().getBit();
p = der;
}
else {
codigo = "";
break;
}
}
return codigo;
}
Estructuras de Datos
© ESPOL 39
2016-1T
EJERCICIO EN CLASE
•Construya el arbol de Huffman con la siguientes
frecuencias
A 15 D 12 G 6
B 6 E 25 H 3
C 7 F 4 I 15

 Empecemos con las dos letras de menor frecuencia

 Se unen y crean un nuevo simbolo
 La frecuencia del nuevo es la suma de los dos ant.
 Se desechan los dos anteriores
 El grupo de letras se vuelve mas pequeño
 Todo se repite hasta que no queden mas letras ind.

Estructuras de Datos
© ESPOL 40
2016-1T
EJERCICIO EN CLASE

Estructuras de Datos
© ESPOL 41
2016-1T