Montículos binarios

Agenda

1. Montículos binarios
2. Colas con prioridad
3. Ordenamiento heapSort

2
 Montículo
• Un montículo (o heap en inglés) es una agrupación piramidal de elementos.
Montículos
binarios • Un montículo es igual a un árbol en cuanto a su estructura (relación jerárquica no lineal de
uno a muchos).
Colas con
prioridad

Ordenamiento
heapSort

3
 Montículo binario
En los montículos binarios, como su nombre lo indica, cada nodo tiene a lo sumo dos “hijos”, es decir,
Montículos igual que en los árboles binarios. Los elementos de un montículo binario deben cumplir unas reglas que
binarios son diferentes a las de un árbol binario de búsqueda.

Colas con
prioridad Regla 1
• Si el montículo es ascendente, los hijos de un padre deben ser mayores o iguales a este. Por
Ordenamiento
consiguiente, en la parte más alta del montículo, en la cima (lo que en el árbol sería la raíz), siempre se
heapSort
encuentra el elemento más pequeño.
Regla 2:
• Todos los niveles son completos excepto el último.
Regla 3:
• En el último nivel los nodos se sitúan lo más a la izquierda posible.

4
 Montículo binario - II
Nota 1: No existe un orden entre los elementos que se encuentran
Montículos
en un mismo nivel. ¿Cuáles de los
binarios siguientes son
Nota 2: En el resto de esta clase nos referiremos a montículos montículos binarios?
Colas con ascendentes, sabiendo que en el caso de los descendentes las
prioridad operaciones son análogas.
Ordenamiento
heapSort 1 1 1

5 20 6 20 6 20

7 7 5 7 25

5
 Estructura de un montículo binario
Montículos
Nodo Nodo Nodo Nodo
binarios MB father = null father = 0x11 father = 0x11 father = 0x12
top = 0x11 left = 0x12 left = 0x14 left = null left = null
Colas con size = 4 right = 0x13 right = null right = null right = null
prioridad 1 5 7 10

Ordenamiento 0x10 0x11 0x12 0x13 0x14

heapSort

1
Dibuje el montículo
binario resultante
5 7

10
6
 Inserción en un montículo binario
• Al insertar un elemento se deben garantizar dos cosas:
Montículos
binarios 1. Se mantenga la estructura del montículo (árbol binario semicompleto).
2. Se mantenga el orden del montículo (todo padre menor o igual que sus hijos o
Colas con viceversa).
prioridad

Ordenamiento
heapSort • Para lograrlo es necesario realizar un proceso en dos pasos:
Paso 1: Agregar el nuevo elemento en el último nivel y a la derecha del más a la
derecha o, si el último nivel está completo, como hijo izquierdo del más a la izquierda
de ese nivel.
Paso 2: En caso que se incumpla la propiedad de orden se deben reorganizar los
elementos, “subiendo” el nuevo elemento por medio de intercambios hasta que quede
en el lugar que le corresponde.

7
 Inserción en un montículo binario - II
• Supongamos que deseamos insertar el 4.
Montículos
binarios

Colas con 1 1
prioridad
5 7 4 7
Ordenamiento
heapSort

10 4 10 5

¿Dónde lo ponemos? ¿Ahí queda bien?

8
 p = new nodo(e); // e es el elemento a insertar
n++;
if (n == 1) { Paso 1 - Agregar
top = p;
} else {
a = n;
Montículos while (a>1) {
r.addFirst(a%2); //r es una pila
0
binarios 1
a = a/2; //división entera
}
Colas con
q = top;
prioridad for (i=0; i<r.size()-1; i++) { 5 7

1
if (r.pop() == 0) {
Ordenamiento q = q.left;
heapSort } else { N=5
10 4
q = q.right;
} Pila = |0|1|
}
if (r.pop()==0) {
q.left = p;
} else {
q.right = p; ¿Cuál seria la eficiencia?
}
} O(log(N))

9
 Paso 2 - Reorganizar
if (p != top) {
Montículos while (p.father.elm > p.elm) {
binarios aux = p.father.elm;
1
p.father.elm = p.elm;
p.elm = aux;
Colas con
p = p.father;
prioridad if (p == top) { 4 7
break;
Ordenamiento }
heapSort }
} 10 5

¿Cuál seria la eficiencia ¿Cuál seria la eficiencia?

total de la inserción?
O(log(N))
O(log(N)) + O(log(N)) = O(log(N))
10
 Búsqueda en un montículo binario
• Se deben considerar dos casos:
Montículos 1. Cuando se busca el menor elemento.
binarios
2. Cuando se busca cualquier otro.
Colas con
prioridad
• El primer caso es sumamente simple pues según las reglas que vimos previamente dicho
Ordenamiento elemento estará en la cima del montículo, del cual se tiene referencia, y por tanto la
heapSort eficiencia será:
O(1)

• En el segundo caso, dado que no existe un orden entre los elementos que se encuentran
en un mismo nivel del montículo, no es posible usar un algoritmo eficiente como en el
caso del árbol binario de búsqueda. Por tanto es necesario recurrir a un recorrido por
TODO el montículo (sea pre-orden, en-orden, o post-orden), el cual ya sabemos, tiene una
eficiencia: O(N)
O(N)

11
 Ejemplo búsqueda pre-orden
Montículos buscar(elm e){
binarios encontrado = false;
buscar(top, e);
Colas con return encontrado;
prioridad }

buscar(nodo p, elm e){

Ordenamiento
if (p.elm == e) {
heapSort encontrado = true;
} else if (p.left != NULL) {
buscar(p.left, e);
{ else if (p.right != NULL) {
buscar(p.right, e);
}
}

12
 Borrado en un montículo binario
• Se deben considerar dos casos:
Montículos
binarios
1. Cuando se borra la cima, es decir, el menor elemento.
2. Cuando se borra cualquier otro.
Colas con
prioridad • El primer caso requiere de dos pasos:
Paso 1: Reemplazar la cima del montículo por el elemento más abajo más a la derecha.
Ordenamiento
Encontrar dicho elemento toma O(log(n)) y hacer el reemplazo O(1), es decir, todo junto
heapSort
es O(log(n)).
Paso 2: Similar a como cuando se inserta, se debe “bajar” dicho elemento por el camino
de valores mínimos hasta la posición que le corresponda. En caso de empate se elige el
izquierdo.
En el peor de los casos se debe bajar hasta el último nivel, y por tanto, es O(log(n)).
Al juntar los dos pasos se tiene O(log(n)) + O(log(n)) = O(log(n)).

13
 Borrado en un montículo binario - I
Borrar el 1
Montículos 1 9
binarios

Colas con 4 20 4 20
prioridad

Ordenamiento 7 9 7
heapSort

4
4

7 20
9 20

9
7
14
 Borrado en un montículo binario - II
En el segundo caso de borrado (cualquier otro elemento que no sea la cima
Montículos del montículo) se debe incluir un paso previo: buscar el elemento.
binarios
Entonces:
Colas con
prioridad Paso 0: Buscar el elemento, lo cual ya vimos es O(n). Si dicho elemento está lo
más abajo más a la derecha del montículo se borra y listo, en caso contrario se
Ordenamiento
sigue con los pasos 1 y 2.
heapSort
Paso 1: Reemplazar dicho elemento por el más abajo más a la derecha del
montículo, lo cual en el peor de los casos es O(log(n)).
Paso 2: Se baja o sube dicho elemento hasta la posición que le corresponda, lo
cual nuevamente es en el peor de los casos O(log(n)).
Al juntar los tres pasos se tiene O(n) + O(log(n)) + O(log(n)) = O(n).

15
 Borrado en un montículo binario - III
Borrar el 4
Montículos 1 1
binarios

Colas con 4 20 9 20
prioridad

Ordenamiento 7 9 7
heapSort

7 20

9
16
 Ejercicio
• Insertar 23 26 35 42 30 28 50 65 15 5 en un montículo binario ascendente y
Montículos luego borrar dos veces la cima.
binarios

Colas con
prioridad

Ordenamiento
heapSort

17
 Resultado final
Montículos
binarios

Colas con
prioridad

Ordenamiento
heapSort

18
 Colas con prioridad
• El comportamiento del montículo binario, así como su eficiencia, hacen que muchos
Montículos lenguajes (incluido Java) se basen en él para implementar las colas con prioridad.
binarios
• En una cola con prioridad, como su nombre lo indica, el elemento a salir (pop) no es el
Colas con primero en entrar (FIFO) sino aquel con mayor prioridad (valor mayor o menor según se
prioridad necesite).

Ordenamiento
heapSort ¿Por qué se usa esta alternativa en vez de usar listas enlazadas como en las colas FIFO?

Pues porque, si se hiciera así, el push se reduciría a O(1) pero el pop se aumentaría a
O(N), o bien el pop se reduciría a O(1) pero el push se aumentaría a O(N).

19
 Ordenamiento heapSort
• Un montículo binario puede ser usado para ordenar
Montículos un arreglo. ¿Cómo?, muy sencillo: se insertan uno a
binarios uno los elementos del arreglo en un montículo
binario hasta que este quede con los n elementos.
Colas con Luego se extrae n veces la cima del montículo
prioridad reinsertándolos al arreglo de forma secuencial.

Ordenamiento
heapSort //sea A el arreglo que se desea ordenar
//B un montículo binario inicialmente vacío
for (i=0; i<n; i++) {
B.add(A[i]);
}
¿Cuál seria la for (i=0; i<n; i++) {
A[i] = B.poll();
eficiencia?
}

N*O(log(N)) + N*(O(1)+O(log(N)) = O(N*log(N))

20
 Dato interesante
• Partiendo del hecho que un montículo binario corresponde a un
Montículos árbol binario semi-completo recargado a la izquierda, la mayoría
binarios de los lenguajes lo implementan, no como un árbol, sino como
un arreglo.
Colas con
prioridad • Lo anterior garantiza las mismas eficiencias en las operaciones de inserción, búsqueda y
borrado, pero con dos ventajas:
Ordenamiento 1. Mejores constantes.
heapSort
2. Menos consumo de memoria.
• Queda de tarea analizar como serian la inserción, búsqueda y borrado con esta
implementación.

21
 Tabla resumen
Montículos Estructura Inserción Indexación Búsqueda Borrado
binarios Montículo O(log(N)) No aplica O(1) para la O(log(N)) para
binario cima. la cima.
Colas con implementado
prioridad mediante árbol O(N) para O(N) para
cualquier otro. cualquier otro.
Ordenamiento
heapSort
• Y analizamos que la eficiencia del algoritmo heapSort es O(N*log(N))

22
 Referencias
• Liang, Y. D. (2015). Introduction to Java programming, comprehensive.
Pearson Higher 10th Edition -> Chapters 20 and 24.
• Aguilar, L. J., & Zahonero, I. (2007). Estructuras de datos en Java. McGraw-
Hill/Interamericana de España -> Capítulo 11.
• Material del curso de Estructuras de Datos del profesor Julián Moreno.

23