UNIVERSIDAD NACIONAL

DE MOQUEGUA
Tema:

Ordenacin por Montculos (Heapsort)

Carrera:

Ing. De Minas

Ciclo:

1er. Ciclo

Curso:

Introduccin a la Programacin

Integrante:
Condori Aamuro Giancarlo

Moquegua Per

Ordenacin por montculos

o Heapsort
Heapsort
La estructura de datos heap es un arreglo de objetos que pueden ser vistos
como un rbol binario completo (solo pueden faltar nodos al final del ltimo
nivel).
Este algoritmo consiste en almacenar todos los elementos del vector a ordenar
den un montculo (heap), y luego extraer el nodo que queda como nodo raz del
montculo (cima) en sucesivas iteraciones obteniendo el conjunto ordenado.
Basa su funcionamiento en una propiedad de los montculos, por la cual, la
cima contiene siempre al mayor elemento (o menor, segn sea el caso) de
todos los almacenados en el.

Caractersticas
Es un algoritmo que se construye utilizando las propiedades de los montculos

binarios.
El orden de ejecucin para el peor caso es O(Nlog(N)), siendo N el tamao de
la entrada.
Aunque tericamente es ms rpido que los algoritmos de ordenacin vistos
hasta aqu, en la prctica es ms lento que el algoritmo de ordenacin de Shell
utilizando la secuencia de incrementos de Sedgewick.

Definicin de un montculo
Decimos que un rbol binario satisface la condicin de montculo si cada
padre es mayor que sus hijos. A diferencia de los rboles binarios ordenados,
no hay ninguna condicin que relacione a los hijos de un mismo padre (ni
mucho menos a los de padres distintos). Finalmente, diremos que un rbol
binario es un montculo si satisface la condicin de montculo y, adems, es
un rbol binario completo, es decir, todos los niveles del rbol (excepto tal vez
el ltimo) estn repletos, y en el ltimo nivel todos los hijos estn acumulados
del mismo lado (digamos a la izquierda).
As, de los siguientes rboles binarios, el primero no satisface la condicin de
montculo, el segundo no es completo y el tercero s es un montculo.

rbol binario completo

Es una estructura de datos en la cual cada nodo siempre tiene un hijo izquierdo
y un hijo derecho.
No pueden tener ms de dos hijos (de ah el nombre "binario")

Breve repaso de las propiedades de los montculos binarios

(heaps).
Recordemos que un montculo Max es un rbol binario completo cuyos
elementos estn ordenados del siguiente modo: para cada subrbol se cumple
que la raz es mayor que ambos hijos. Si el montculo fuera Min, la raz de cada
subrbol tiene que cumplir con ser menor que sus hijos.
Recordamos que, si bien un montculo se define como un rbol, para
representar ste se utiliza un array de datos, en el que se acceden a padres e
hijos utilizando las siguientes transformaciones sobre sus ndices. Si el
montculo est almacenado en el array A, el padre de A[i] es A [i/2] (truncando
hacia abajo), el hijo izquierdo de A[i] es A [2*i] y el hijo derecho de A[i] es A
[2*i+1].
Al insertar o eliminar elementos de un montculo, hay que cuidar de no destruir
la propiedad de orden del montculo. Lo que se hace generalmente es construir
rutinas de filtrado (que pueden ser ascendentes o descendentes) que tomen un
elemento del montculo (el elemento que viola la propiedad de orden) y lo
muevan verticalmente por el rbol hasta encontrar una posicin en la cual se
respete el orden entre los elementos del montculo.
Tanto la insercin como la eliminacin (eliminarmino eliminarMaxsegn sea
un montculo Min o Max respectivamente), de un elemento en un montculo se
realizan en un tiempo O (log(N)), peor caso (y esto se debe al orden entre sus
elementos y a la caracterstica de rbol binario completo).

Estrategia general del algoritmo

A grandes rasgos el algoritmo de ordenacin por montculos consiste en meter

todos los elementos del array de datos en un montculo MAX, y luego realizar N
veces eliminarMax(). De este modo, la secuencia de elementos eliminados
nos ser entregada en orden decreciente.

Implementacin prctica del algoritmo

Existen dos razones por las que la estrategia general debe ser refinada: el uso
de un tad auxiliar (montculo binario) lo cual podra implicar demasiado cdigo
para un simple algoritmo de ordenacin, y la necesidad de memoria adicional
para el montculo y para una posible copia del array. Estas cosas tambin
implican un gasto en velocidad.
Lo que se hace es reducir el cdigo al mximo reducindose lo ms posible la
abstraccin a un montculo. Primero que nada, dado el array de datos, este no
es copiado a un montculo (insertando cada elemento). Lo que se hace es, a
cada elemento de la mitad superior del array (posiciones 0,1,..., N/2) se le
aplica un filtrado descendente (se "baja" el elemento por el rbol binario hasta
que tenga dos hijos que cumplan con el orden del montculo. Esto bastar para
hacer que el array cumpla con ser un montculo binario.
Notamos tambin que al hacer un eliminar Max () se elimina el primer
elemento del array, se libera un lugar a lo ltimo de este. Podemos usar esto
para no tener que hacer una copia del array para meter las eliminaciones
sucesivas. Lo que hacemos es meter la salida de eliminar Max () luego del
ltimo elemento del montculo. Esto hace que luego de N-1 eliminar Max (), el
array quede ordenado de menor a mayor.
Para ahorrar cdigo queremos lograr insertar y eliminar Max () con una sola
rutina de filtrado descendente. Ya explicamos cmo hacer que el array de datos
A preserve el orden de los elementos de un montculo. Lo que hacemos para
ordenarlo usando slo la rutina de filtrado descendente es un eliminar Max ()
intercambiando el primer elemento del array por el ltimo del montculo y
filtrar el nuevo primer elemento hasta que se respete el orden Max. Quiz esto
quede ms claro mirando el cdigo.

Algoritmo de ordenacin por montculos

<? Php
Function filtrado_desc (& $A, $i, $N)
{
/* queremos que se respete el orden MAX del montculo */
$tmp = $A [$i];
$hijo = 2 * $i;
if (($hijo < $N) && ($A[$hijo + 1] > $A[$hijo]))
$hijo++;
While (($hijo <= $N) && ($tmp < $A [$hijo]))
{
/* Elijo bien el hijo */

If (($hijo < $N) && ($A [$hijo + 1] > $A [$hijo]))

$hijo++;
$A [$i] = $A [$hijo];
$i = $hijo;
$hijo = 2 * $i;
}
$A [$i] = $tmp;
}
Function intercambiar (& $A, $i, $j)
{
$tmp = $A [$i];
$A [$i] = $A [$j];
$A [$j] = $tmp;
}
Function heapsort (& $A, $N)
{
//$i;
/* Ingreso los datos en el montculo (ordeno) */
For ($i = $N / 2; $i >= 0; $i--)
filtrado_desc ($A, $i, $N);
/* Saco los datos y los meto al final para obtener el array ordenado */
For ($i = $N - 1; $i > 0; $i--){
Intercambiar ($A, 0, $i);
filtrado_desc ($A, 0, $i - 1);
}
}
Function imprimirDatos ($A)
{
For ($i=0; $i<count ($A);$i++){
Echo "A[".$i."] = ".$A[$i]."<br>";
}
Echo "<br>";
}
$A=$_POST ["A"];
Echo "<p align='center'><font size='5'><b>ORDENACIN POR EL MTODO
HEAPSORT</b></font> </p>";
Echo "<br>Datos ingresados<br>";
imprimirDatos ($A);
heapsort ($A,count($A));
Echo "<br>Datos ordenados<br>";
ImprimirDatos($A);
Echo "<br><a href='index.html'>Nueva Ordenacin</a>";
?>

Inicio

Leer
N
A
[ ]
For: i= N/2; i> =0;
I-Tmp = A [I]
HIJO = 2 * i

Si

Hijo ++

Hijo < N
A [hijo + 1] > A
[hijo]

No

Hijo < = N
Tmp < A
[hijo]

Hijo ++

(Hijo < N) ^A [hijo + 1] > A

[hijo]

A [i] A [hijo]
I hijo
Hijo 2 * i

A [i] tmp

For: i n 1; i >
0; i --Hijo < = i 1
^
Tmp
Hijo=<Ai [01]
Tmp
<A
0
]=
=+
i ]]A
AATmp
[[ hijo]
AA1
[[ 0>
[
hijo
]
AHijo
[ i [hijo]
]=
=2
tmp
*0

Tmp A [0]
A [0] A [i]
A [i] tmp

Tmp A [0]
Hijo 2*0

Si
Hijo< N
A [hijo + 1]
>A[hijo]

Hijo ++

No

Hijo < = i 1
^
Tmp < A
[hijo]
si
(Hijo < i 0) ^ A [hijo +1]
No
> A [hijo]
Hijo ++
A [0] A [hijo]
0 hijo
Hijo 2 * 0

A [0] tmp

I 0; i <
N; i ++
A [i]

Fin