UNIVERSIDAD NACIONAL DE

CAJAMARCA
FACULTAD DE INGENIERA

ESCUELA ACADMICO PROFESIONAL DE

INGENIERA DE SISTEMAS
Tema:
Solucin
Ordenamiento
de prctica
por Montculos
Curso:
Algoritmos II
y Estructura de Datos
II
Docente:
Docente:
Malpica Rodrguez Manuel
Cuenca Cabrera Jorge Luis
Alumno:
Alumno:
Ramos Vsquez Ronal Ivn
Marrufo Huamn Alex
Ramos Vsquez Ronal Ivn
Ruiton Tanta Esau

Cajamarca,03
Cajamarca,06
dede
Octubre
del 2016
julio
del 2016

ORDENAMIENTO POR MONTCULOS (HEAPSORT)

Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un
montculo (heap), y luego extraer el nodo que queda como nodo raz del montculo
(cima) en sucesivas iteraciones obteniendo el conjunto ordenado.
Qu es un Heap?
Este heap o montculo es un rbol binario donde todos los padres son mayores que sus
hijos.
Este rbol binario tiene que ser completo, es decir, que debe tener todos sus niveles
llenos, excepto el ltimo y en este ltimo nivel todos los hijos estn a un mismo lado.
Qu es un HeapSort?
Es un algoritmo de ordenacin basado en comparaciones de elementos que utiliza un
heap para ordenarlos.
Tambin podemos decir que es un algoritmo de ordenacin no recursivo, no estable, con
complejidad computacional.
Cmo funciona el HeapSort?
Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un
montculo y luego extraer el nodo que queda como raz en sucesivas iteraciones
obteniendo el conjunto ordenado. Basa su funcionamiento en una propiedad de los
montculos, por la cual, la cima siempre (depende de cmo se defina) contendr el
mayor o menor elemento del montculo.
Pasos:
1.
2.
3.
4.
5.

Se construye el montculo inicial a partir del arreglo original.

Se intercambia la raz con el ltimo elemento del montculo.
El ltimo elemento queda ordenado.
El ltimo elemento se saca del montculo, no del arreglo.
Se restaura el montculo haciendo que el primer elemento baje a la posicin que
le corresponde, si sus hijos son menores.
6. La raz vuelve a ser el mayor del montculo.
7. Se repite el paso 2 hasta que quede un solo elemento en el montculo

Ejemplo:

1
5

6
0

0
8

1
6

4
4

2
7

1
2

3
5

CONSTRUCCIN DE UN MONTCULO
1. Se inserta el elemento en la primera posicin disponible.
2. Se verifica si su valor es mayor que el de su padre. Si se cumple esta condicin,
entonces se efecta el intercambio. Si no, entonces el algoritmo se detiene y el
elemento queda ubicado en su posicin correcta.
*** El paso 2 se aplica de manera recursiva mientras el elemento tenga un padre.

ELIMINACIN DE LA RAZ
El proceso para obtener los elementos ordenados se efecta eliminando la raz del
montculo de forma repetida n veces.
1. Se remplaza la raz con el elemento que ocupa la ltima posicin del montculo.
2. Se crea un montculo con los elementos restantes.

Se hace comparaciones he intercambios segn sea el caso

Se hace comparaciones he intercambios segn sea el caso

IMPLEMENTACIN EN JAVA

Mtodo HeapSort
package ordenamiento;
public class HeapSort {
private static int N;
/* Ordenar Funcin */
public static void sort(int arr[]) {
heapify(arr);
for (int i = N; i > 0; i--) {
swap(arr, 0, i);
N = N - 1;
maxheap(arr, 0);
}
}
/* Funcin para construir un Monticulo */
public static void heapify(int arr[]) {
N = arr.length - 1;
for (int i = N / 2; i >= 0; i--)
maxheap(arr, i);
}
/* Funcin para intercambiar elemento ms grande en el Monticulo
*/

public static void maxheap(int arr[], int i) {

int left = 2 * i;
int right = 2 * i + 1;
int max = i;
if (left <= N && arr[left] > arr[i])
max = left;
if (right <= N && arr[right] > arr[max])
max = right;
if (max != i) {
swap(arr, i, max);
maxheap(arr, max);
}
}
/* Funcin para intercambiar dos nmeros */
public static void swap(int arr[], int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}

Prueba HeapSort
package ordenamiento;
import java.util.Scanner;
public class PruebaHeapSort {
public static void main(String[] args) {
Scanner leer = new Scanner(System.in);
System.out.println("\t\t=== Probando HeapSort ===\n");
System.out.println("\tARREGLO INICIALIZADO\n");
int v1[] = { 15, 60, 8, 16, 44, 27, 12, 35 };
System.out.println("Areglo Original");
for (int i = 0; i < v1.length; i++) {
System.out.print(v1[i] + "\t");
}
System.out.println();
HeapSort.sort(v1);
System.out.println("\nArreglo ordenado\n");
for (int i = 0; i < v1.length; i++) {
System.out.print(v1[i] + "\t");
}
/* Acepta el nmero de elementos */
System.out.println("\n");
System.out.println("\tARREGLO INGRESADO POR TECLADO\n");
System.out.println("Introduzca el nmero de elementos ");
int n = leer.nextInt();
/* Hacer arreglo de n elementos */
int v[] = new int[n];
/* Aceptar los elementos */
for (int i = 0; i < v.length; i++) {
System.out.print("Ingrese N " + (i + 1) + ": ");
v[i] = leer.nextInt();
}
/* Imprime Elementos Desordenados */
for (int i = 0; i < v.length; i++) {
System.out.print(v[i] + "\t");
}
/* Mtodo de llamada clase */
HeapSort.sort(v);
/* Imprimir el arreglo ordenad0o */
System.out.println("\nElementos Ordenados ");
for (int i = 0; i < v.length; i++) {
System.out.print(v[i] + "\t");
}
leer.close();
}
}