Tabla de Contenidos

2.2. HEAPSORT 27
Lo primero es notar que i decrece, por lo que no podemos hacer inducción en i. Demostraremos
esta propiedad entonces por inducción en la cantidad de iteraciones del loop, que llamaremos n.
Note que la relación directa entre n e i es n = N − i.
B.I. Si n = 0 ⇒ i = N, o sea antes de empezar el ciclo, sabemos que A cumple la propiedad de heap
ya que se ejecutó Build-Heap, luego se cumple (2). Ahora, tanto (1) como (3) se cumplen ya
que los índices quedan fuera del arreglo (no hay nada que demostrar).
H.I. Supongamos que se cumple para n (o equivalentemente para i = N − n), o sea que luego del
paso n–ésimo de la iteración las propiedades (1), (2) y (3) son ciertas, es decir:
1. A[N − n..N − 1] está ordenado,
2. A[0..N − n − 1] cumple la propiedad de heap, y
3. A[0..N − n − 1] ≤ A[N − n..N − 1].
T.I. Analicemos ahora el siguiente paso de la iteración, o sea la iteración n+1, lo que querría decir
que i = N −(n+1). Por la H.I. (2) sabemos que A[0] ≥ A[0..N −n−1] ya que A[0..N −n−1]
cumple la propiedad de heap, y además por (3) sabemos que A[0] ≤ A[N − n..N − 1], por lo
que al intercambiar A[0] con A[N − (n + 1)] = A[N − n − 1] se tiene que A[N − n − 1..N − 1]
está ordenado y que A[0..N − n − 2] ≤ A[N − n − 1..N − 1]. Ahora el cambio pudo haber
hecho que A[0..N − n − 2] dejara de cumplir la propiedad de heap. Hay que notar que justo
antes de la llamada a Heapify el valor de π cumple con π = i = N −n−2, por lo que luego de
la llamada a Heapify, estaremos seguros que A[0..N − n − 2] cumple la propiedad de heap.
Finalmente hemos demostrado que:
- A[N − (n + 1)..N − 1] está ordenado,
- A[0..N − (n + 1) − 1] cumple la propiedad de heap, y
- A[0..N − (n + 1) − 1] ≤ A[N − (n + 1)..N − 1].
Por inducción se sigue que la propiedad se cumple para toda iteración del loop principal.
Finalmente cuando el loop termina, tenemos que i = 1, o sea que n = N − 1, de donde se concluye
(reemplazando n = N −1 en (1) y (3)) que después de la última iteración A[0..N −1] está ordenado.
Complejidad de Heapsort
Para analizar la complejidad de Heap-Sort lo primero que notamos es que se ejecuta una vez
el procedimiento Build-Heap y que el procedimiento Heapify se ejecuta Θ(N) veces. Dado que
Build-Heap toma tiempo Θ(N) y que Heapify toma tiempo Θ(log N) cuando se ejecuta desde la
raíz de un heap con N elementos, podemos asegurar que Heap-Sort toma tiempo O(N+N log N) =
O(N log N) en el peor caso. ¿Podemos dar una cota más ajustada como lo hicimos en el caso de
Build-Heap? La respuesta esta vez es no. Un argumento a favor para intentar encontrar una cota
más ajustada es el hecho de que Heapify no se ejecuta siempre sobre un heap de N elementos, de
hecho, en cada iteración se disminuye el valor de π lo que nos dice que en cada iteración Heapify
se ejecuta sobre un heap cada vez más pequeño. Un argumento muy fuerte en contra de intentar
✷