Montículos Binarios (Binary Heaps)

Presentación del tema: "Montículos Binarios (Binary Heaps)"— Transcripción de la presentación:

1 Montículos Binarios (Binary Heaps)
En este punto vamos a: - definir un montículo de mínimos - ver ejemplos - operaciones sobre montículos: Head/Cabecera Dequeue/Borrado/Desencolado Enqueue/Insertar/Encolar

2 Definición Un heap o montículo es una estructura de datos similar a un árbol binario de búsqueda pero ordenado de distinta forma por prioridades y además se representa siempre como un árbol binario completo representado como un arreglo.

3 Definición Un montículo es un árbol binario completo tal que puede :
Estar vacío El valor de la prioridad en la raíz es mayor, (menor) o igual que la prioridad de cualquiera de sus hijos Ambos subárboles son montículos o heap … max

4 Definición Un árbol binario no vacio es un montículo de mínimos si:
la clave asociada con la raíz es menor o igual a la asociada con los sub-árboles ambos sub-arboles son montículos de mínimos

5 A partir de la definición:
un nodo simple es un montículo de mínimos todas las claves en el sub-árbol son mayores que la raíz

6 Propiedades del heap Debe cumplir dos propiedades:
un árbol binario completamente lleno, con la posible excepción del nivel más bajo, el cual se rellena de izquierda a derecha. Estos árboles se denominan árboles binarios completos. Todo nodo debe ser mayor que todos sus descendientes. Por lo tanto, el maximo estará en la raíz y su búsqueda y eliminación se podrá realizar rápidamente.

7 Características Todos los heaps son árboles binarios. No son necesariamente ABBs. El árbol está completamente balanceado excepto el último nivel, que debe estar lleno de izquierda a derecha. Para un elemento del heap en la posición k, sus hijos deberán estar en las posiciones 2k y 2k+1 del heap. Un HEAP puede representarse en un arreglo. Toda lista ordenada es un heap.

8 Ejemplo El siguiente es un montículo de mínimos:

9 Ejemplo Para visualizar las propiedades coloreamos los nodos:

10 Ejemplo Observaciones:
el árbol de la izquierda tiene tanto el elemento más pequeño (7) como el mayor (89) no existen relaciones entre items con prioridad similar

11 Head Obtener el elemento más pequeño:
retornar la raíz En nuestro ejemplo, el mínimo elemento es 3

12 Dequeue (Desencolado/Borrado)
Para eliminar el mínimo elemento simplemente se promueve el nodo del sub-árbol que tiene el menor valor Luego, se aplica recursión hacia abajo del árbol que ha promovido el valor más pequeño

13 Dequeue (Desencolado/Borrado)
Usando nuestro ejemplo, eliminamos 3:

14 Dequeue (Desencolado/Borrado)
Promovemos 7 (el menor de 7 y 12) a la raíz:

15 Dequeue (Desencolado/Borrado)
En el sub-árbol de la izquierda, promovemos el 9:

16 Dequeue (Desencolado/Borrado)
Recursivamente, promovemos el 19:

17 Dequeue (Desencolado/Borrado)
Finalmente , 55 es el nodo hoja, entonces lo promovemos y liberamos el nodo

18 Dequeue (Desencolado/Borrado)
Repitiendo esta operación otra vez, podemos remover 7:

19 Dequeue (Desencolado/Borrado)
Si removemos 9, ahora la promoción debe hacerse desde el sub-árbol de la derecha:

20 Enqueue (Encolado/Inserción)
La inserción en un montículo puede hacerse ya bien: en la raíz (insertar el mayor elemento en uno de los sub-árboles) en una hoja (mover hacia arriba si es más pequeño que el padre) Nosotros utilizaremos el segundo enfoque

21 Enqueue (Encolado/Inserción)
En el heap anterior insertaremos 17 Seleccionamos un nodo arbitrario para insertar un nuevo nodo hoja:

22 Enqueue (Encolado/Inserción)
El nodo 17 es menor que el nodo 32, entonces, los intercambiamos

23 Enqueue (Encolado/Inserción)
El nodo 17 es menor que el 31, entonces, los intercambiamos

24 Enqueue (Encolado/Inserción)
El nodo 17 es menor que el nodo 19, entonces, los intercambiamos

25 Enqueue (Encolado/Inserción)
El nodo 17 es mayor que el 12, entonces, hemos terminado

26 Enqueue (Encolado/Inserción)
Observación: tanto el sub-árbol de la derecha como el de la izquierda de 19 son mayores que 19, entonces eso nos garantiza que no se tiene que enviar un nuevo nodo abajo Este proceso se llama percolation (infiltrado), esto es, los elementos más livianos (pequeños) se mueven hacia arriba desde abajo del montículo.

27 Encolado en un árbol completo
Si queremos insertar en un árbol completo, sólo se necesita ubicar el nuevo nodo como una hoja en la posición adecuada e infiltrarlo

28 Encolado en un árbol completo
Por ejemplo, insertando 25:

29 Encolado en un árbol completo
Infiltramos 25 arriba hasta su ubicación apropiada El montículo resultante es todavía un árbol completo

30 Desencolado en un árbol completo
Qué pasa cuando se remueve el elemento mínimo? Si nosotros simplemente infiltramos, crearemos un árbol no completo, ej., eliminando 12:

31 Desencolado en un árbol completo
Estrategia alternativa: luego de infiltrar 32 arriba, el último elemento en el árbol binario completo (32) es menor que cualquier sub-árbol, entonces lo copiamos arriba:

32 Desencolado en un árbol completo
El resultado ahora es un árbol completo

33 Desencolado en un árbol completo
Removiendo el siguiente elemento mínimo:

34 Desencolado en un árbol completo
Removiendo el siguiente elemento mínimo:

35 Desencolado en un árbol completo
Removiendo el siguiente elemento mínimo:

36 Operaciones Insertar / Agregar Eliminar

37 Agregar Pasos para insertar en un Heap
Agregamos el nodo. (de izquierda a derecha) Comparamos son su padre. Si es mayor permutamos hasta llegar a la raíz Repetimos el paso 1 y 2 hasta llenar el nivel. Una vez llenado ese nivel pasamos al siguiente nivel.

38 Agregar (Ejemplo) => => => Agregamos el 19 Agregamos el 24
14 24 19 Comparamos el 24 > 19 Comparamos el 14 > 24 Agregamos el 30 30 24 24 => => 24 14 19 14 30 14 19 30 19 Comparamos el 30 > 19 Comparamos el 30 > 24

39 Agregar (Ejemplo) => => Agregamos el 25 Agregamos el 18 30 30 30
24 14 25 14 25 14 19 25 19 24 19 24 18 Comparamos el 25 > 24 Agregamos el 5 Comparamos el 18 > 14 30 30 25 18 => 25 18 19 24 14 19 24 5 14

40 Eliminar Siempre se elimina la RAIZ Pasos para eliminar
Eliminamos la raíz del heap Una vez eliminada remplazamos la raíz con el último nodo del último nivel. Comparamos si los hijos de la nueva raíz son menores Si son menores no se hace ninguna permutación Si son mayores (o uno de ellos) se hace permutación con el hijo mayor. Repetimos los pasos anteriores hasta no tener nodos para eliminar.

41 Eliminar (Ejemplo) => => => Eliminamos el 30
Comparamos si el 5 > 25 30 5 => 25 24 25 24 19 14 5 18 19 14 18 Comparamos si el 5 > 19 25 25 => => 5 24 24 19 19 14 18 5 14 18

42 Eliminar ( Ejemplo) => => => Eliminamos el 25
Comparamos si el 24 > 19 Y si el 24 >18 24 25 18 => 18 24 19 19 24 19 5 5 14 14 18 5 14 Comparamos si el 14 > 19 Comparamos si el 14 > 5 Eliminamos el 24 24 19 14 => => 18 18 18 14 19 19 5 5 14 5

43 Eliminar (Ejemplo) => => => => Eliminamos 19 Comparamos
si el 5 > 14 Comparamos si el 14 > 18 19 => 5 => 5 18 14 18 14 18 14 5 Eliminamos 18 18 5 => 18 14 => 5 14 5 14 14 5

44 Eliminar (Ejemplo) => => Los nodos eliminados fueron:
Eliminamos 14 Eliminamos 5 14 => => 5 5 vació 5 Los nodos eliminados fueron: