View
234
Download
0
Category
Preview:
Citation preview
Unidad VII – Estructura de datos
Ordenamientos internosMétodo Heapsort
ordenamiento por montículos
Deini Resendiz BenitezMartin Pacheco Chavez
Método Heapsort• El método de ordenación heapsort se
conoce también como por ordenación por montículos, y trabaja con montículos máximos.
• Es necesario saber que es un montículo, la inserción y eliminación de los elementos, para el entendimiento de este método.
¿Qué es un montículo?
• Un montículo se define como: Una estructura basada en un árbol, donde cada nodo padre es mayor a sus nodos hijos y además toda la estructura esta balanceada.
Existen:• Los montículos máximos tienen la
característica de que cada nodo padre tiene un valor mayor que el de cualquiera de sus nodos hijos.
• Los montículos mínimos, el valor del nodo padre es siempre menor al de sus nodos hijos.
Método Heapsort• Este método es el más eficiente de los métodos de ordenación que
trabajan con estructuras tipo arboles. La idea central de este algoritmo se basa en dos operaciones:
1. Construir un montículo.2. Eliminar la raíz del montículo en forma repetida.
Árbol binario de búsqueda Montículo máximo
60
46 79
6530 55
79
55 65
6030 46
Gráficamente
Árbol binario de búsqueda Montículo mínimo
60
46 79
6530 55
30
46 60
6579 55
Gráficamente
No se considera como montículo si los niveles no se encuentran balanceados
Estructura no balanceada
79
65
55
60
46
30
Para balancearlo habría que reacomodar los elementos.
Estructura balanceada
79
55 65
6030 46
79
55 65
6030 46
79 > 55 & 65
55 > 30 & 46 65 > 60
Todos los nodos son mayores a sus hijos.
Montículo máximo
• Para representar un montículo en un arreglo se debe considerar lo siguiente.
• Teniendo el nodo padre en la posición K:– Su hijo izquierdo es 2 * K.– Su hijo derecho es 2 * K + 1.
Montículo máximo representado en un arreglo
79
55 65
6030 46
79 55 65 30 46 60
1 2 3 4 5 6
Para cualquier nodo K:Su hijo izquierdo es 2 * K.Su hijo derecho es 2 * K + 1.
A
79 55 65 30 46 60
1 2 3 4 5 6
Para cualquier nodo K:Su hijo izquierdo es 2 * K.Su hijo derecho es 2 * K + 1.
Ejemplo. Si K = 2, entonces:Su hijo Izquierdo es: A[2*k] = A[2*2] = A[4]
El hijo izquierdo de A[2] es A[4]
A
Calculo de Hijos
79
55 65
6030 46
79 55 65 30 46 60
1 2 3 4 5 6
Para cualquier nodo no raíz K:Su padre es K/2.
Si K es impar, se considera K/2 - 0.5
Ejemplo. Si K = 5, entonces:Su padre es: A[K/2] = A[5/2-0.5] = A[2]
El padre de A[5] es A[2]
A
Calculo de Padres
79
55 65
6030 46
Algoritmo de inserción1. Se inserta el elemento en la primera posición
disponible.2. Se verifica si su valor es mayor que el de su padre.
Si se cumple esta condición, entonces se efectúa el intercambio. Si no, entonces el algoritmo se detiene y el elemento queda ubicado en su posición correcta.*** El paso 2 se aplica de manera recursiva mientras el elemento tenga un padre.
1. Construcción de un montículo
• Se dan n valores enteros cualquiera:
15 60 08 16 44 27 12 35
Inserción de 15 15 60 08 16 44 27 12 35
Considerando que se tiene un montículo vacío:
1515
raíz
Paso 1:El numero 15 llega en la primera posición disponible.
Algoritmo:
Inserción de 60 15 60 08 16 44 27 12 35
15 60
15
raíz
60
Paso 1:El numero 60 llega en la primera posición disponible.
Algoritmo:
Inserción de 60 15 60 08 16 44 27 12 35
15 60
15
raíz
60
Paso 2:Se verifica si 60 es mayor a su padre, en este caso 15.
¿60 > 15?
Algoritmo:
Inserción de 60 15 60 08 16 44 27 12 35
60 15
60
raíz
15
Paso 2:Como 60 si es mayor a 15, se efectúa un intercambio. Después de esto la inserción finaliza.
Algoritmo:
Inserción de 08 15 60 08 16 44 27 12 35
60 15 08
60
raíz
15
Paso 1:El numero 08 llega en la primera posición disponible.
Algoritmo:
08
Inserción de 08 15 60 08 16 44 27 12 35
60 15 08
60
raíz
15
Paso 2:Se verifica si 8 es mayor a su padre, en este caso 60.
Algoritmo:
08
¿8 > 60?
Inserción de 08 15 60 08 16 44 27 12 35
60 15 08
60
raíz
15
Paso 2:Como 8 no es mayor a 60, el algoritmo finaliza y la inserción finaliza.
Algoritmo:
08
Inserción de 16 15 60 08 16 44 27 12 35
60 15 08 16
60
raíz
15
Paso 1:El numero 16 llega en la primera posición disponible.
Algoritmo:
08
16
Inserción de 16 15 60 08 16 44 27 12 35
60 15 08 16
60
raíz
15
Paso 2:Se verifica si 16 es mayor a su padre, en este caso 15.
Algoritmo:
08
16 ¿16 > 15?
Inserción de 16 15 60 08 16 44 27 12 35
60 16 08 15
60
raíz
16
Paso 2:Como 16 si es mayor a 15, se efectúa un intercambio. Se aplica la recursividad del paso 2.
Algoritmo:
08
15
Inserción de 16 15 60 08 16 44 27 12 35
60 16 08 15
60
raíz
16
Paso 2:Se verifica si 16 es mayor a su padre, en este caso 60.
Algoritmo:
08
15 ¿16 > 60?
Inserción de 16 15 60 08 16 44 27 12 35
60 16 08 15
60
raíz
16
Paso 2:Como 16 no es mayor a 60, el algoritmo finaliza y la inserción finaliza.
Algoritmo:
08
15
Inserción de 44 15 60 08 16 44 27 12 35
60 16 08 15 44
60
raíz
16
Paso 1:El numero 44 llega en la primera posición disponible.
Algoritmo:
08
15 44
Inserción de 44 15 60 08 16 44 27 12 35
60 16 08 15 44
60
raíz
16
Paso 2:Se verifica si 44 es mayor a su padre, en este caso 16.
Algoritmo:
08
15 44 ¿44 > 16?
Inserción de 44 15 60 08 16 44 27 12 35
60 44 08 15 16
60
raíz
44
Paso 2:Como 44 si es mayor a 16, se efectúa un intercambio. Se aplica la recursividad del paso 2.
Algoritmo:
08
15 16
Inserción de 44 15 60 08 16 44 27 12 35
60 44 08 15 16
60
raíz
44
Paso 2:Se verifica si 44 es mayor a su padre, en este caso 60.
Algoritmo:
08
15 16 ¿44 > 60?
Inserción de 44 15 60 08 16 44 27 12 35
60 44 08 15 16
60
raíz
44
Paso 2:Como 44 no es mayor a 60, el algoritmo finaliza y la inserción finaliza.
Algoritmo:
08
15 16
Inserción de 27 15 60 08 16 44 27 12 35
60 44 08 15 16 27
60
raíz
44
Paso 1:El numero 27 llega en la primera posición disponible.
Algoritmo:
08
15 16 27
Inserción de 27 15 60 08 16 44 27 12 35
60 44 08 15 16 27
60
raíz
44
Paso 2:Se verifica si 27 es mayor a su padre, en este caso 8.
Algoritmo:
08
15 16 27
¿27 > 8?
Inserción de 27 15 60 08 16 44 27 12 35
60 44 27 15 16 8
60
raíz
44
Paso 2:Como 27 si es mayor a 8, se efectúa un intercambio. Se aplica la recursividad del paso 2.
Algoritmo:
27
15 16 08
Inserción de 27 15 60 08 16 44 27 12 35
60 44 27 15 16 8
60
raíz
44
Paso 2:Se verifica si 27 es mayor a su padre, en este caso 60.
Algoritmo:
27
15 16 08
¿27 > 60?
Inserción de 27 15 60 08 16 44 27 12 35
60 44 27 15 16 8
60
raíz
44
Paso 2:Como 27 no es mayor a 60, el algoritmo finaliza y la inserción finaliza.
Algoritmo:
27
15 16 08
Inserción de 12 15 60 08 16 44 27 12 35
60 44 27 15 16 8 12
60
raíz
44
Paso 1:El numero 12 llega en la primera posición disponible.
Algoritmo:
27
15 16 08 12
Inserción de 12 15 60 08 16 44 27 12 35
60 44 27 15 16 8 12
60
raíz
44
Paso 2:Se verifica si 12 es mayor a su padre, en este caso 27.
Algoritmo:
27
15 16 08 12
¿12 > 27?
Inserción de 12 15 60 08 16 44 27 12 35
60 44 27 15 16 8 12
60
raíz
44
Paso 2:Como 12 no es mayor a 27, el algoritmo finaliza y la inserción finaliza.
Algoritmo:
27
15 16 08 12
Inserción de 35 15 60 08 16 44 27 12 35
60 44 27 15 16 8 12 35
60
raíz
44
Paso 2:El numero 35 llega en la primera posición disponible.
Algoritmo:
27
15 16 08 12
35
Inserción de 35 15 60 08 16 44 27 12 35
60 44 27 15 16 8 12 35
60
raíz
44
Paso 2:Se verifica si 35 es mayor a su padre, en este caso 15.
Algoritmo:
27
15 16 08 12
35 ¿35 > 15?
Inserción de 35 15 60 08 16 44 27 12 35
60 44 27 35 16 8 12 15
60
raíz
44
Paso 2:Como 35 si es mayor a 15, se efectúa un intercambio. Se aplica la recursividad del paso 2.
Algoritmo:
27
35 16 08 12
15
Inserción de 35 15 60 08 16 44 27 12 35
60 44 27 35 16 8 12 15
60
raíz
44
Paso 2:Se verifica si 35 es mayor a su padre, en este caso 44.
Algoritmo:
27
35 16 08 12
15 ¿35 > 44?
Inserción de 35 15 60 08 16 44 27 12 35
60 44 27 35 16 8 12 15
60
raíz
44
Paso 2:Como 35 no es mayor a 44, el algoritmo finaliza y la inserción finaliza.
Algoritmo:
27
35 16 08 12
15
15 60 08 16 44 27 12 35
De los números:
60 44 27 35 16 8 12 15
Se obtiene el montículo:
60
raíz
44 27
35 16 08 12
15
Construcción de Montículos - Métodos necesarios.
//int a[] es el monticulo. int i es el hijo.public static int padre(int a[], int i){ //Si i es la raíz, no tiene padre, por lo tanto regresa un -1. if(i == 0) return -1; //Regresa -1. else return (i - 1)/ 2; //Regresa la posición del padre del elemento i.}
Este método regresa la posición del padre de un elemento en un montículo. El único elemento que no tiene padre, es el elemento a[0], la cual es la raíz.
Construcción de Montículos - Métodos necesarios.
//int a[] es el monticulo. int i es el hijo.public static int hijoIzq(int a[], int i){
//Si i NO tiene hijo izquierdo, entonces if(2*i+1 >= a.length) //Regresa -1 return -1; //Si no else //Regresa la posicion del hijo izquierdo. return (2 * i + 1);}
Este método regresa la posición en el arreglo del hijo izquierdo del elemento i.Retorna un -1 si el elemento no tiene hijo izquierdo.
Construcción de Montículos - Métodos necesarios.
//int a[] es el monticulo. int i es el hijo.public static int hijoDer(int a[], int i){
//Si i NO tiene hijo izquierdo, entonces if((2*i+1)+1 >= a.length) //Regresa -1 return -1; //Si no else //Regresa la posicion del hijo izquierdo. return (2 * i + 1) + 1;}
Este método regresa la posición en el arreglo del hijo derecho del elemento i.Retorna un -1 si el elemento no tiene hijo derecho.
Construcción de Montículos - Métodos necesarios.private static int[] hacerMonticulo(int a[]){ int n = a.length; for (int i = 0; i < n; i++) { //Si tiene padre, entonces if(padre(a, i) != -1){ //Se busca al padre de i y se asigna el valor. int padre = a[padre(a, i)]; //Si el elemento i es mayor que el padre, entonces. if(a[i] > padre){ //Hacer el intercambio. int aux = padre; a[padre(a, i)] = a[i]; a[i] = aux; //Se realiza de nuevo el metodo de manera recursiva. hacerMonticulo(a); } } } return a; //Regresar lo resultante de a. }
Método Heapsort• Una vez hecha la construcción de un montículo partiendo de un
arreglo, se puede proceder a el paso 2 del método de ordenación.
*** El efecto de ordenación, surge una vez realizando el paso 2. ***
1. Construir un montículo.
2. Eliminar la raíz del montículo en forma repetida.
2. Eliminación de la raíz.
• El proceso para obtener los elementos ordenados se efectúa eliminando la raíz del montículo de forma repetida n veces.
Algoritmo de eliminación1. Se remplaza la raíz con el elemento que ocupa la ultima
posición del montículo.2. Se crea un montículo con los elementos restantes.
60 44 27 35 16 8 12 15
Dado el montículo:
60
raíz
44 27
35 16 08 12
15
Eliminación de 60
60
raíz
44
Paso 1:La raíz se elimina, y es remplazada por el ultimo elemento
Algoritmo:
27
35 16 08 12
15
60 44 27 35 16 8 12 15
Eliminación de 60
15
raíz
44
Paso 1:60 es remplazado por 15. El elemento eliminado se coloca en la ultima posición.
Algoritmo:
27
35 16 08 12
15 44 27 35 16 8 12 60
Eliminación de 60
Paso 2:Se crea un montículo con los elementos restantes
Algoritmo:
15
raíz
44 27
35 16 08 12
15 44 27 35 16 8 12 60
Eliminación de 60
44
raíz
25
Paso 2:Se crea un montículo con los elementos restantes
Algoritmo:
27
15 16 8 12
44 35 27 15 16 8 12 60
Eliminación de 44
44
raíz
25
Paso 1:La raíz se elimina, y es remplazada por el ultimo elemento
Algoritmo:
27
15 16 8 12
44 35 27 15 16 8 12 60
Eliminación de 44
12
raíz
25
Paso 1:44 es remplazado por 12. El elemento eliminado se coloca en la ultima posición.
Algoritmo:
27
15 16 8
12 35 27 15 16 8 44 60
Eliminación de 44
12
raíz
25
Paso 2:Se crea un montículo con los elementos restantes.
Algoritmo:
27
15 16 8
12 35 27 15 16 8 44 60
Eliminación de 44
35
raíz
16
Paso 2:Se crea un montículo con los elementos restantes.
Algoritmo:
27
12 15 8
35 16 27 12 15 8 44 60
Eliminación de 35
35
raíz
16
Paso 1:La raíz se elimina, y es remplazada por el ultimo elemento.
Algoritmo:
27
12 15 8
35 16 27 12 15 8 44 60
Eliminación de 35
8
raíz
16
Paso 1:35 es remplazado por 8. El elemento eliminado se coloca en la ultima posición.
Algoritmo:
27
12 15
8 16 27 12 15 35 44 60
Eliminación de 35
35
raíz
16
Paso 2:Se crea un montículo con los elementos restantes.
Algoritmo:
27
12 15
8 16 27 12 15 35 44 60
Eliminación de 35
27
raíz
15
Paso 2:Se crea un montículo con los elementos restantes.
Algoritmo:
16
8 12
27 15 16 8 12 35 44 60
Eliminación de 27
27
raíz
15
Paso 1:La raíz se elimina, y es remplazada por el ultimo elemento.
Algoritmo:
16
8 12
27 15 16 8 12 35 44 60
Eliminación de 27
12
raíz
15
Paso 1:27 es remplazado por 12. El elemento eliminado se coloca en la ultima posición.
Algoritmo:
16
8
12 15 16 8 27 35 44 60
Eliminación de 27
12
raíz
15
Paso 2:Se crea un montículo con los elementos restantes.
Algoritmo:
16
8
12 15 16 8 27 35 44 60
Eliminación de 27
16
raíz
12
Paso 2:Se crea un montículo con los elementos restantes.
Algoritmo:
15
8
16 12 15 8 27 35 44 60
Eliminación de 16
16
raíz
12
Paso 1:La raíz se elimina, y es remplazada por el ultimo elemento.
Algoritmo:
15
8
16 12 15 8 27 35 44 60
Eliminación de 16
8
raíz
12
Paso 1:16 es remplazado por 8. El elemento eliminado se coloca en la ultima posición.
Algoritmo:
15
8 12 15 16 27 35 44 60
Eliminación de 16
8
raíz
12
Paso 2:Se crea un montículo con los elementos restantes.
Algoritmo:
15
8 12 15 16 27 35 44 60
Eliminación de 16
15
raíz
8
Paso 2:Se crea un montículo con los elementos restantes.
Algoritmo:
12
15 8 12 16 27 35 44 60
Eliminación de 15
15
raíz
8
Paso 1:La raíz se elimina, y es remplazada por el ultimo elemento.
Algoritmo:
12
15 8 12 16 27 35 44 60
Eliminación de 15
12
raíz
8
Paso 1:15 es remplazado por 12. El elemento eliminado se coloca en la ultima posición.
Algoritmo:
12 8 15 16 27 35 44 60
Eliminación de 15
12
raíz
8
Paso 2:Se crea un montículo con los elementos restantes..
Algoritmo:
12 8 15 16 27 35 44 60
Eliminación de 12
12
raíz
8
Paso 1:La raíz se elimina, y es remplazada por el ultimo elemento.
Algoritmo:
12 8 15 16 27 35 44 60
Eliminación de 12
8
raíz
Paso 1:12 es remplazado por 8. El elemento eliminado se coloca en la ultima posición.
Algoritmo:
8 12 15 16 27 35 44 60
Eliminación de 8
8
raíz
Paso 1: Al quedar un solo elemento en el montículo, se finaliza el algoritmo.
Algoritmo:
8 12 15 16 27 35 44 60
Al finalizar obtenemos el arreglo
8 12 15 16 27 35 44 60
Arreglo ordenado ascendentemente.
Método Heapsort
1. Construir un montículo.
2. Eliminar la raíz del montículo en forma repetida.
Eliminación de raíz - Métodos necesarios.
//Elimina la raíz del montículo a[], donde el tamaño es n.public static int[] eliminarRaiz(int a[], int n){
// n = tamaño del montículoint aux;aux = a[n-1];a[n-1] = a[0];a[0] = aux; return a;
}
Este método regresa un arreglo, donde la raíz se ha intercambiado por el ultimo elemento del arreglo
Método heapsortpublic static int[] heapsort(int a[]){
int n = a.length; //Paso 1. Hacer montículo. int monticulo[] = hacerMonticulo(a, n); //Paso 2. Eliminar la raíz repetidas veces. for (int i = 0; i < monticulo.length; i++) { monticulo = eliminarRaiz(monticulo, n-i);
monticulo = hacerMonticulo(monticulo, n-i-1);}
return monticulo; }
8 12 15 16 27 35 44 60
15 60 8 16 44 27 12 35
60 44 27 35 16 8 12 15
Arreglo inicial
Paso 1: Hacer Montículo
Paso 2: Repetir: Eliminar la raíz y hacer un moitculo.
Método heapsort
• Gracias.
Fuentes:• Estructura de Datos . Tercera Edición – Osvaldo Cairó y Silvia Guardati.
McGrawHill Editorial.
• Estructuras de Datos en Java - Luis Joyanes Aguilar. McGrawHill Editorial.
Recommended