INSTITUTO TECNOLÓGICO DE LÁZARO CÁRDENAS Estructura de datos Ingeniería en Sistemas Computacionales Computacionales Unidad 5 Equipo: Erick Amando Hernández Toledo Dominic Campos Avilés Kevin Daniel Román Martínez Profesor: Gabriel Nava Fombona Cd. Y PUERTO LÁZARO CÁRDENAS MICHOACÁN 30 de Octubre del 2014
Unidad 5 Introduc Introducció ciónn ................................. .................................................. ................................. ................................. .................................. ........................... .......... 3 5.1. Algoritmos Algoritmos de Ordenamiento Ordenamiento Internos................... ......... ................... ................... ................... .................. ............ ... 3 5.1.1 Burbuja..... Burbuja..................... ................................. .................................. .................................. ................................. ................................. ..................... 3 Ejemplo: Ejemplo: ................................. .................................................. ................................. ................................. .................................. ........................... .......... 5 5.1.2 Quicksor Quicksortt ............................... ................................................ .................................. ................................. .................................. ...................... .... 6 Ejemplo: Ejemplo: ................................. .................................................. ................................. ................................. .................................. ........................... .......... 7 5.1.3 Shell Shell Sort.................. ................................... .................................. .................................. ................................. ................................. ..................... 9 Ejemplo: Ejemplo: ................................. .................................................. ................................. ................................. .................................. ......................... ........10 5.1.4 Radix Radix ................................. .................................................. ................................. ................................. .................................. ......................... ........13 Ejemplo: Ejemplo: ................................. .................................................. ................................. ................................. .................................. ......................... ........14 5.2. Algoritmos Algoritmos de ordenamiento ordenamiento Externos ................... ......... ................... ................... ................... .................. ........... 18 5.2.1 Intercalación ................................................................................................ 18 Ejemplo: Ejemplo: ................................. .................................................. ................................. ................................. .................................. ......................... ........18 5.2.2 Mezcla Directa ............................................................................................ 20 Ejemplo: Ejemplo: ................................. .................................................. ................................. ................................. .................................. ......................... ........21 5.2.3 Mezcla Natural ............................................................................................ 22 Ejemplo: Ejemplo: ................................. .................................................. ................................. ................................. .................................. ......................... ........22
Introducción En esta unidad veremos el uso de los algoritmos de ordenamiento, conoceremos sus ventajas y desventajas y así saber cuál usar en diferentes ocasiones que se nos puedan presentar en un futuro cuando queramos realizar algún programa. Ordenar significa reagrupar o reorganizar un conjunto de datos u objetos en una secuencia específica, la cual puede ser de dos formas distintas: Ascendente (menor a mayor) o Descendente (mayor a menor). Los métodos de ordenación se clasifican en dos categorías: Ordenación interna (de arreglos) y Ordenación externa (de archivos). La ordenación interna o de arreglos, recibe este nombre ya que los elementos o componentes del arreglo se encuentran en la memoria principal de la computadora.
5.1. Algoritmos de Ordenamiento Internos
5.1.1 Burbuja El método de ordenación por intercambio directo o método de la burbuja, consiste en ciclar repetidamente a través de la lista, comparando elementos adyacentes de dos en dos. Si un elemento es mayor que el que está en la siguiente posición se intercambian.
Ventajas:
Fácil implementación. No requiere memoria adicional.
Desventajas:
Muy lento. Realiza numerosas comparaciones. Realiza numerosos intercambios. Este algoritmo es uno de los más pobres en rendimiento.
Primer procedimiento del método de la burbuja:
1. Generar un ciclo que inicie desde uno hasta el número de elementos del arreglo. 2. Generar un segundo ciclo dentro del anterior que inicie desde cero hasta el número de elementos del arreglo menos dos. 3. Dentro del segundo ciclo debe existir una comparación que determina el tipo de ordenamiento (ascendente o descendente) entre el primer elemento (posición generado por el segundo ciclo) y el segundo elemento (el que le sigue), si la respuesta a la condición es verdadera se realiza un intercambio entre los dos elementos. 4. Para realizar el intercambio se genera un almacenamiento temporal, el cual guarda el dato del primer elemento, el segundo elemento toma el lugar del primero y en el lugar del segundo se coloca lo que contiene el almacenamiento temporal.
Una vez que los ciclos terminan la estructura debe quedar ordenada de forma ascendente o descendente, pero este procedimiento es considerado como el pero de los casos ya que si el número de elementos de la estructura es de 100, se tienen que realizar 9900 comparaciones entes de terminar la ejecución del método.
Segundo procedimiento del método de la burbuja:
1. Generar un ciclo que inicie desde cero hasta el número de elementos menos dos. 2. Generar un segundo ciclo desde el valor del ciclo anterior más uno hasta el número de elementos menos uno; 3. Dentro del segundo ciclo debe existir una comparación que determina el tipo de ordenamiento (ascendente o descendente) entre el primer elemento (posición generada por el primer ciclo) y el segundo elemento (posición generada por el segundo ciclo), si la respuesta a la condición es verdadera se realiza un intercambio entre los dos elementos. 4. Para realizar el intercambio se genera un almacenamiento temporal, el cual guarda el dato del primer elemento, el segundo elemento toma el lugar del primero y en el lugar del segundo se coloca lo que contiene el almacenamiento temporal. Una vez que los ciclos terminan la estructura debe quedar ordenada, la diferencia con el procedimiento anterior radica en el número de comparaciones y posibles intercambios que se presentan, en este segundo procedimiento, es menor ya que cada pasada que se le da al arreglo se realiza una comparación menos que en la pasada anterior.
Ejemplo: public static void burbuja(int [] A){ int i, j, aux; for(i=0;i
5.1.2 Quicksort
El ordenamiento rápido (quicksort) es un algoritmo que permite, en promedio, ordenar n elementos en un tiempo proporcional a n log n. Es la técnica de ordenamiento más rápida conocida. El algoritmo original es recursivo.
Algoritmo fundamental:
Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote. Resituar los demás elementos de la lista a cada lado del pivote. La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del pivote, y otra por los elementos a su derecha. Repetir este proceso de forma recursiva para cada sublista mientras éstas contengan más de un elemento. En el mejor caso, el pivote termina en el centro de la lista, dividiéndola en dos sublistas de igual tamaño. En el peor caso, el pivote termina en un extremo de la lista. En el caso promedio, el orden es O(n·log n).
Elegir un pivote:
El pivote será el primer elemento del arreglo, El pivote será el elemento que esta a la mitad del arreglo, o Que el pivote se elija de entre tres elementos del arreglo (cualesquiera), los cuales se deben comparar para seleccionar el valor intermedio de los tres y considerarlo como el pivote.
Técnica de reacomodo de los elementos del lado izquierdo y derecho :
Recorrer el arreglo simultáneamente con izq y der: por la izquierda con izq (desde el primer elemento), y por la derecha con der(desde el último elemento). Mientras el arreglo en su posición izq (arreglo[izq]) sea menor que el pivote, continuamos el movimiento a la derecha. Mientras el arreglo en su posición der (arreglo[der]) sea mayor que el pivote, continuamos el movimiento a la izquierda. Terminando los movimientos se compara los índices y si izq es menor o igual al der, se intercambian los elementos en esas posiciones y las posiciones se cambian izq a la derecha y der a la izquierda. Repetir los pasos anteriores hasta que se crucen los índices (izq sea menor o igual a der).
El punto en que se cruzan los índices es la posición adecuada para colocar el pivote, porque sabemos que a un lado los elementos son todos menores y al otro son todos mayores (o habrían sido intercambiados).
Ejemplo:
public class QuickSort{ public static void main(String a[]){ int i; int array[] = {12,9,4,99,120,1,3,10,13};
System.out.println(" Quick Sort\n"); System.out.println("Valores antes de QuickSort:\n"); for(i = 0; i < array.length; i++) System.out.print( array[i]+" "); System.out.println(); quick_srt(array,0,array.length-1); System.out.print("\n\n\nValores despues de QuickSort:\n\n"); for(i = 0; i = n) { return; } int mid = array[(lo + hi) / 2]; while (lo < hi) { while (lo mid) { hi--; } if (lo < hi) { int T = array[lo]; array[lo] = array[hi]; array[hi] = T; } } if (hi < lo) { int T = hi; hi = lo; lo = T; } quick_srt(array, low, lo); quick_srt(array, lo == low ? lo+1 : lo, n); } }
5.1.3 Shell Sort
Este método se conoce con el nombre de inserción por incrementos decrecientes. Shell Propone que las comparaciones entre elementos se efectúen con salto de mayor tamaño pero con incrementos decrecientes, así, los elementos quedaran ordenados en el arreglo más rápidamente. Este método, es una mejora del método de inserción directa, utilizado cuando el array tiene un gran número de elementos. En este método no se compara a cada elemento con el de su izquierda, como en el de inserción, sino con el que está a un cierto número de lugares (llamado salto) a su izquierda. Este salto es constante, y su valor inicial es N/2 (siendo N el número de elementos, y siendo división entera). Se van dando pasadas hasta que en una pasada no se intercambie ningún elemento de sitio. Entonces el salto se reduce a la mitad, y se vuelven a dar pasadas hasta que no se intercambie ningún elemento, y así sucesivamente hasta que el salto vale 1. Shell sort es una generalización de la ordenación por inserción, con dos observaciones en mente: La ordenación por inserción es eficiente si la entrada está "casi ordenada". La ordenación por inserción es ineficiente, en promedio, porque se mueve valores sólo una posición a la vez.
Ejemplo:
Algoritmo
ENTERO N+1 Repetir mientras ( ENTERO >1 ) ENTERO parte entera ( ENTERO entre 2) Y BAND VERDADERO Repetir mientras ( BAN = VERDADERO) BAND FALSO i 1 Repetir mientras (( i + ENTERO)
N)
Si A [ I ] > L[I + ENTERO ] entonces aux L[I] L[I]
L[I+ENTERO] A[I+ ENTERO] AUX
BAND VERDADER O Fin del condicional } Hacer I I + 1 {Fin del paso ciclo } {Fin del ciclo de paso} {Fin del ciclo del paso} (INT, I y AUX son variables de tipo entero Band es una variable de tipo booleano).
INT N+1 Repetir mientras (INT >1) INT parte entera ( INT entre 2 ) Bandera True Repetir mientras (Bandera == True) BAND FALSO i 1 Repetir mientras ( ( i + INT )
N)
Si L [ i ] > L[ i + INT ] entonces aux L[ i ] L[ i ] L[ i + INT ] L[ i + INT ] aux Bandera True FinSi i i + 1 FinRepetir FinRepetir FinRepetir
Analisis de Eficiencia del Metodo de Shell
No se ha podido establecer hasta el momento la mejor secuencia de incrementos cuando N es grande.
En l969 Pratt descubrió que el tiempo de ejecución del algoritmo es del orden de n*(log n).
Se mencionará que en unos estudio realizados en la universidad de Stanford en 1971 por Peterson y Rusell muestran que las mejores secuencia para los valores de N comprendidos entre 100 y 60 000 son las presentadas a continuación.
1,3,5,9, ... ,2ª +1 1,3,7,15, ... ,2ª-1 SECUENCIAS 1,3,5,11, ... ,(2ª1)/3 1,4,13,40, ... ,(3ª-1)/2 Donde ª = 0,1,2,3,......
5.1.4 Radix
El método de Radix considera la estructura de los elementos a ordenar. La ordenación se realiza comparando números o carácter en la misma posición.
Considera que los datos que serán ordenados están representados en una Base B del sistema de números ( B = Base = Radix = Raíz)
Si B = 10, el sistema considerado es el decimal.
B = 10
Decimal
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
B= 2
Binario
(0, 1)
B= 8
Octal
(0, 1, 2, 3, 4, 5, 6, 7)
B = 16
Hexadecimal
Ejemplo:
Ordenación Radix:
Ordenación Radix:
Ordenación Radix:
Si B = 2, los datos a clasificar están en forma Binaria:
00012 = 110 00102 = 210 00112 = 310 01002 = 410
Datos Iniciales
1ra Columna
2da Columna
Datos Clasificados
5.2. Algoritmos de ordenamiento Externos
5.2.1 Intercalación
Algoritmo de ordenación externa, que permite organizar los elementos de un archivo, de forma ascendente o descendente. Consiste en leer un registro de cada archivo y compararlos, el menor es almacenando en el archivo de resultado y el otro se compara con el siguiente elemento del archivo si existe. El proceso se repite hasta que alguno de los archivos quede vacío y los elementos del otro archivo se almacenan directamente en el archivo resultado.
Ejemplo:
import java.util.Scanner; Public class Intercalacion { public static void main (String[] args) { Scanner dato = new Scanner (System.in); int n = 0; System.out.println("Longitud de arreglo: ");
n= dato.nextInt(); int[] arreglo = new int [n]; for (int i=0 ;i<=n-1 ; i++) { System.out.println("Elemento [" +i+ "]= "); arreglo [i]= dato.nextInt(); }
intercalacion (arreglo,n);
for (int i=0 ;i<=n-1 ; i++) System.out.println("arreglo[i]+", "); }
public static void intercalacion (int[] x, int n) { int[] aux = new int[n]; int tam = 1;
LinfUno = u2 + 1 }
for (i=LinfUno; k
for (i=0 ;i
tam = 2 }
5.2.2 Mezcla Directa
a) Descripción Este método de llama mezcla porque combina dos o más secuencias en una sola secuencia ordenada por medio de la selección repetida de los componentes accesibles en ese momento.
Un arreglo individual puede usarse en lugar de dos secuencias si se considera como de doble extremo. En este caso se tomaran elementos de los dos extremos del arreglo para hacer la mezcla. El destino de los elementos combinados se cambia después de que cada par ha sido ordenado para llenar uniformemente las dos secuencias que son el destino. Después de cada pasada los dos extremos del arreglo intercambian de papel, la fuente se convierte en el nuevo destino y viceversa.
b) Algoritmo 1.- Inicio 2.- Dividir la secuencia A en dos mitades denominadas B y C. 3.- Mezclar B y C combinando cada elemento en pares ordenados. 4.- Llamar A la secuencia mezclada y repetir los pasos 1 y 2, esta vez combinando los pares en cuádruples ordenados. 5.- Repetir los pasos anteriores duplicando cada vez la longitud de las secuencias combinadas hasta que quede ordenada la secuencia original. 6.- Fin del Algoritmo .
Ejemplo:
5.2.3 Mezcla Natural
La mezcla natural o mezcla equilibrada es un algoritmo de ordenación externa, que se encarga de organizar los elementos de un archivo de forma ascendente o descendente.
La idea central de este algoritmo consiste en realizar particiones tomando secuencias ordenadas de máxima longitud en lugar de secuencias ordenadas de tamaño fijo previamente determinadas, como la intercalación directa. Posteriormente se realiza la fusión de esas secuencias ordenadas, alternándolas entre los dos archivos auxiliares. Repitiendo este proceso, se logra que el archivo quede completamente ordenado. Para aplicar este algoritmo, se necesitarán cuatro archivos. El archivo original y tres archivos auxiliares. De estos cuatro archivos, dos serán considerados de entrada y dos de salida, alternativamente en cada paso del algoritmo. El proceso termina cuando al finalizar un paso, el segundo archivo de salida quede vacío y el primero queda completamente ordenado.
Ejemplo:
