UNIVERSIDAD SALESIANA DE BOLIVIA INGENIERIA DE SISTEMAS

TEMA: MATERIA: NOMBRE:

MTODOS DE ORDENAMIENTO ALGORITMOS AVANZADOS PAOLA ANDREA CALLISAYA MITA CRUZ NINA SOLEDAD GUTIERREZ PLATA JUAN CARLOS VELAZCO MERLO MARIA EUGENIA

PARALELO: 5A1 DOCENTE: ING. SIMN ONOFRE FECHA: 11/MARZO /2013 LA PAZ BOLIVIA

INDICE

1. Objetivo 2. Antecedente Conceptual 3. Anlisis y diseo de los algoritmos seleccionados 4. Implementacin 5. Pruebas 6. Conclusiones 7. Bibliografa

OBJETIVO

El objetivo general del presente proyecto es el de averiguar cul es el mtodo de ordenamiento, ms efectivo en funcin del tiempo de ejecucin en una matriz.

ANTECEDENTE CONCEPTUAL METODOS DE ORDENAMIENTO Para poder ordenar una cantidad determinada de nmeros almacenadas en un vector o matriz, existen distintos mtodos (algoritmos) con distintas caractersticas y complejidad. Existe desde el mtodo ms simple, como el Bubblesort (o Mtodo Burbuja), que son Simples iteraciones, hasta el Quicksort (Mtodo Rpido), que al estar optimizado usando recursin, su tiempo de ejecucin es menor y es ms efectivo. METODOS ITERATIVOS Estos mtodos son simples de entender y de programar ya que son iterativos, simples ciclos y sentencias que hacen que el vector pueda ser ordenado. Dentro de los Algoritmos iterativos encontramos: Burbuja Insercin Seleccin Shellsort

METODOS RECURSIVOS

Estos mtodos son an ms complejos, requieren de mayor atencin y conocimiento para ser entendidos. Son rpidos y efectivos, utilizan generalmente la tcnica Divide y vencers, que consiste en dividir un problema grande en varios pequeos para que sea ms fcil resolverlos. Mediante llamadas recursivas a s mismas, es posible que el tiempo de ejecucin y de ordenacin sea ms ptimo. Dent de los algoritmos recursivos encontramos: Ordenamiento por Mezclas (merge) Ordenamiento Rpido (quick)

ANALISIS Mtodo de Ordenamiento Burbuja Es el algoritmo de ordenamiento ms sencillo de todos, conocido tambin como mtodo del intercambio directo, el funcionamiento se basa en la revisin de cada elemento de la lista que va a ser ordenada con el elemento siguiente, intercambiando sus posiciones si estn en el orden equivocado, para esto se requieren varias revisiones hasta que ya no se necesiten ms intercambios, lo que indica que la lista ha sido ordenada. El origen del nombre de este algoritmo proviene de la forma con la que suben por la lista los elementos durante los intercambios, tal y como si fueran "burbujas", el algoritmo fundamental de este mtodo es la simple comparacin de elementos siendo as el ms fcil de implementar. Mtodo de Ordenacin Quick Sort (Ordenamiento Rpido): Es el algoritmo de ordenamiento ms eficiente de todos, se basa en la tcnica de "Divide y Vencers", que permite en promedio, ordenar n elementos en un tiempo proporcional a n*log(n). Algoritmo Fundamental: Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote. Resituar los dems elementos de la lista a cada lado del pivote, de manera que a un lado queden todos los menores que l, y al otro los mayores. Los elementos iguales al pivote pueden ser colocados tanto a su derecha como a su izquierda, dependiendo de la implementacin deseada. En este momento, el pivote ocupa exactamente el lugar que le corresponder en la lista ordenada. La lista queda separada en dos sablistas, 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 sablista mientras stas contengan ms de un elemento. Una vez terminado este proceso todos los elementos estarn ordenados. Mtodo de ordenacin de Seleccin La idea bsica de esta ordenacin es encontrar el elemento menor (o mayor ) de la lista y colocarlo en la primera posicin, a continuacin , el elemento siguiente menor (o mayor) se lleva a la segunda posicin y as sucesivamente hasta que queda ordenado.

En el primer paso se efectan n-1 comparaciones, en el segundo n-2 comparaciones y as sucesivamente. O sea que es del orden de O(n a la 2). Solo se requiere un poco de memoria adicional, para guardar unas variables temporales. El ordenamiento puede ser categorizado como mas rpido que el de burbuja. No hay mejora se el arreglo esta ordenado o desordenado. A pesar de ser fcil de codificar, es improbable que se use esta mtodo, ya que se usan matrices o vectores pequeos. Mtodo de ordenacin de Insercin Hacer comparaciones, en donde en cada iteracin forma una lista ordenada. Donde la primera pasada compara lis dos primeros elementos y los ordena. La siguiente pasada, toma el tercer elemento y lo compara con los dos anteriores, colocando a este en su posicin correcta. Ventajas Fcil de implementar Requerimiento minino de memoria. Desventaja Lento Realizar numerosas comparaciones. Es de utilidad para listas ordenadas o semiordenadas, desplazamientos. ya que realiza pocos

De mejores resultados que el de seleccin y el de burbuja, en promedio para todos los elementos, el mtodo tiene complejidad O(n al a2), el cual indica qu es eficiente, nunca intercambia datos con claves iguales. Requerimientos de memoria necesita una variable adicional para los intercambios. Mtodo de Ordenamiento Shell Este mtodo en si es la versin mejora del mtodo de insercin, se le conoce como de insercin con decrementos. El ordenamiento por insercin es eficiente se la lista esta casi ordenada, el ordenamiento por insercin es ineficiente porque mueve los valores una posicin a la vez.

Las ideas bsicas son : Compara los elementos no contiguos, y separados a una gran distancia, si los elementos no estn en orden se intercambian, comienzan especificando un salto, comparando elementos separados por dicho salto y se intercambian si es necesario. Se divide el intercambio por dos y se repite el proceso, al finalizar el recorrido del arreglo, el salto es de uno y la ordenacin funciona como burbuja. Anlisis de eficiencia: Los requerimientos reales de tiempo para un ordenamiento especfico depende del nmero de elementos en la lista y sus valores reales. Se ha demostrado que el orden de Shell sort puede aproximarse a O(n)(logn)n a la 2). Si se usa un a secuencia adecuada de incrementos Ordena subgrupos de elementos separados K unidades (respecto de su posicin en el arreglo) del arreglo original. El valor K es llamado incremento. Despus de que los primeros K subgrupos han sido ordenados (generalmente utilizando INSERCION DIRECTA), se escoge un nuevo valor de K ms pequeo, y el arreglo es de nuevo partido entre el nuevo conjunto de subgrupos. Cada uno de los subgrupos mayores es ordenado y el proceso se repite de nuevo con un valor ms pequeo de K. Eventualmente el valor de K llega a ser 1, de tal manera que el subgrupo consiste de todo el arreglo ya casi ordenado. Al principio del proceso se escoge la secuencia de decrecimiento de incrementos; el ltimo valor debe ser 1. "Es como hacer un ordenamiento de burbuja pero comparando e intercambiando elementos." Cuando el incremento toma un valor de 1, todos los elementos pasan a formar parte del subgrupo y se aplica insercin directa. El mtodo se basa en tomar como salto N/2 (siendo N el nmero de elementos) y luego se va reduciendo a la mitad en cada repeticin hasta que el salto o distancia vale 1.

IMPLEMENTACION

import java.io.*; class Lectura { //metodo para leer cadenas no utilizado en el trabajo grupal public static String Cadena () { String dato = " "; try { InputStreamReader isr = new InputStreamReader (System.in); BufferedReader br = new BufferedReader (isr); dato = br.readLine (); return dato; } catch (IOException e) { System.out.println ("ERROR AL INGRESAR DATO"); return dato; } } // fin string

//Metodo para leer Enteros el ams utilizado en el trabajo grupal public static int Entero () { try { return (Integer.parseInt (Cadena ())); } catch (NumberFormatException e) { // System.out.println ("El dato no es un Entero"); //suprimimos el mensaje para que no aparezca durante la ejecucion de los metofdos de ordenamiento return Integer.MIN_VALUE; } // fin entero }

//METODO PARA LEER REAL public static float Real () { try {

return (Float.valueOf(Cadena()).floatValue()); } catch (NumberFormatException e) { System.out.println ("El dato no es un Real"); return Integer.MIN_VALUE; } // fin real } //Metodo para leer Enteros cortos public static int Entercorto () { try { return (Short.parseShort (Cadena ())); } catch (NumberFormatException e) { System.out.println ("El dato no es un Entero Corto"); return Integer.MIN_VALUE; } // fin entero corto } //Metodo para leer Caracter public static char Caracter() { try { return (Cadena().charAt(0)); } catch (Exception e) { System.out.println ("El dato no es caracter"); return ('\0'); } // fin caracter } public static long EnteroLargo()//operacion que lee un entero largo `:( { try { return(Long.parseLong((Cadena()))); } catch(NumberFormatException e) { return (Long.MIN_VALUE); } }

public static double RealLargo()//operacion para leer un real largo :} { try { Double NumReal=new Double(Cadena()); return(NumReal.doubleValue()); } catch(NumberFormatException e) { return(Double.NaN); } }

import java.util.Random;//libreria que genera numerous aleatorios public class MetodosOrdenamientoMatrices { protected int MAX = 1000; //definimos MAX opcional MetodosOrdenamientoMatrices () { //construxctor sin parametros }

static int [] [] LlenarMatriz (int matriz [] [], int n) { Random r = new Random (); int i, j; for (i = 1 ; i < n + 1 ; i++) for (j = 1 ; j < n + 1 ; j++) { matriz [i] [j] = r.nextInt (); } return matriz; }

public void LlenarMatrizManual (int matriz [] [], int n) { int i, j, cant; do

{ System.out.print ("Cuantos elementos : "); cant = Lectura.Entero (); } while (cant < 1 || cant > MAX); for (i = 0 ; i < cant ; i++) { for (j = 0 ; j < cant ; j++) { System.out.print ("elemento " + i + " " + j + ":"); matriz [i] [j] = Lectura.Entero (); } } n = cant; }//otro metodo de llenado, solo para matrices pequeas

public void cambio (int [] [] matriz, int posi1, int posi2, int posf1, int posf2) { int temp; temp = matriz [posi1] [posi2]; matriz [posi1] [posi2] = matriz [posf1] [posf2]; matriz [posf1] [posf2] = temp; }// tenemos un error que no pudimos solucionar(metodo que utilizamos en el programa)

static void ImprimeMatriz (int matriz [] [], int n) { int i, j; for (i = 0 ; i < n ; i++) { for (j = 0 ; j < n ; j++) { System.out.println ("[" + i + " " + j + "] " + matriz [i] [j]); } System.out.println (); } }//nos da error cuando intentamos imprimir desde la posicion [ 1 1 ] //por eso no la utilizamos en el programa

static void ImprimeMatriz (int n, int matriz [] []) { // este metodo de imprimir presenta errores int i; int j;

if (n > 0) { for (i = 0 ; i < n ; i++) { for (j = 0 ; j < n ; i++) { System.out.print (matriz [i] [j] + "\t"); System.out.println ("\n"); } } } else System.out.println ("Esta Vacio"); }

static int [] [] OrdenamientoBurbuja (int matriz [] [], int n) { int t = n * n, i, j; for (i = (t - 1) ; i >= 0 ; i--) { for (j = 1 ; j <= i ; j++) { int a = j / n; int b = j % n; int c = (j - 1) / n; int d = (j - 1) % n; int temp; if (matriz [a] [b] < matriz [c] [d]) { temp = matriz [c] [d]; // analizar el procedimiento "cambio" para menos repeticiones matriz [c] [d] = matriz [a] [b]; matriz [a] [b] = temp; } } } return matriz; }

static int [] [] OrdenamientoShellSort (int [] [] matriz, int n) { int i, j, temp, t = n * n; int a, b, c, d;

for (i = 1 ; i < t ; i++) { a = i / n; b = i % n; c = (i - 1) / n; d = (i - 1) % n; temp = matriz [a] [b]; for (j = i ; j > 0 && matriz [c] [d] > temp ; j--, a = j / n, b = j % n, c = (j - 1) / n, d = (j - 1) % n) { matriz [a] [b] = matriz [c] [d]; } matriz [a] [b] = temp; } return matriz; }

static int [] [] OrdenamientoPorInsercion (int [] [] matriz, int n) { int i, j, temp, t = n * n, a, b, c, d; for (i = 1 ; i < t ; i++) { a = i / n; b = i % n; c = (i - 1) / n; d = (i - 1) % n; for (j = i ; j > 0 && matriz [c] [d] > matriz [a] [b] ; j--, a = j / n, b = j % n, c = (j - 1) / n, d = (j - 1) % n) { temp = matriz [c] [d]; matriz [c] [d] = matriz [a] [b]; matriz [a] [b] = temp; } } return matriz; }

static int [] [] OrdenamientoPorSeleccion (int [] [] matriz, int n) { int i, j, t = n * n, a, b, c, d; int min, temp; for (i = 0 ; i < t - 1 ; i++) { min = i; for (j = i + 1 ; j < t ; j++)

{ a = j / n; b = j % n; c = (min) / n; d = (min) % n; if (matriz [a] [b] < matriz [c] [d]) min = j; } a = i / n; b = i % n; c = (min) / n; d = (min) % n; temp = matriz [a] [b]; matriz [a] [b] = matriz [c] [d]; matriz [c] [d] = temp; } return matriz; }

static int [] [] OrdenamientoRapidoQuickSort (int [] [] matriz, int l, int u, int n) { int a, b, c, d; if (l >= u) return matriz; int m = l, temp; for (int i = l + 1 ; i <= u ; i++) { a = i / n; b = i % n; c = l / n; d = l % n; if (matriz [a] [b] < matriz [c] [d]) { m++; a = i / n; b = i % n; c = m / n; d = m % n; temp = matriz [c] [d]; matriz [c] [d] = matriz [a] [b]; matriz [a] [b] = temp; } } a = l / n; b = l % n; c = m / n;

d = m % n; temp = matriz [a] [b]; matriz [a] [b] = matriz [c] [d]; matriz [c] [d] = temp; matriz = OrdenamientoRapidoQuickSort (matriz, l, m - 1, n); // se llama a si misma matriz = OrdenamientoRapidoQuickSort (matriz, m + 1, u, n); return matriz; } }

class usametodos { public static void main (String [] Pao) { MetodosOrdenamientoMatrices matriz = new MetodosOrdenamientoMatrices (); long time_init, time_total;// System.out.println ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); System.out.println ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); System.out.println ("~| Universidad Salesiana de Bolivia |~~~"); System.out.println (~~| |~~~"); System.out.println ("~| |~~~"); System.out.println("~| TRABAJO GRUPAL DEL PRIMER PARCIA |~~~"); System.out.println ("~~~| I/2013 |~~~"); System.out.println ("~~~| |~~~"); System.out.println ("~~~| |~~~"); System.out.println ("~~~| Materia : Algoritmos Avanzados |~~~"); System.out.println ("~~~| Tema : Metodos de Ordenamiento |~~~"); System.out.println ("~~~| Aplicados en Matrices |~~~"); System.out.println ("~~~|Docente : Ing. Simon Onofre Lopez |~~~"); System.out.println ("~~~| Estudiantes : ~ Cruz Nina Soledad |~~~"); System.out.println ("~~~| ~ Callisaya Mita Paola Andrea |~~~"); System.out.println ("~~~| ~ Gutierrez Plata Juan Carlos |~~~"); System.out.println ("~~~| ~ Velasco Merlo Maria Eugenia |~~~"); System.out.println ("~~~| Paralelo : 5 ' A ' 1 |~~~"); System.out.println ("~~~| Fecha : 10 / 03 / 2013 |~~~"); System.out.println ("~~~| |~~~"); System.out.println ("~~~| La Paz - Bolvia |~~~"); System.out.println ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); System.out.println ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");

System.out.println ("Presione una tecla para continuar... "); int s = Lectura.Entero (); System.out.println ("\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r"); System.out.print ("Ingrese una dimeion para la matriz cuadrada a ordenar: "); int n = Lectura.Entero (); int Burbuja [] [], Seleccion [] [], Shell [] [], Insercion [] [], QuickSort [] [], m [] [] = new int [n + 1] [n + 1]; matriz.LlenarMatriz (m, n); System.out.println (" Se ha llenado la matriz cuadrada con numeros aleatorios en cada posicion y\r se esta procediendo a ordenarla por medio de 5 metodos de ordenamiento\r diferentes, porfavor espere... "); matriz.LlenarMatriz (m, n); time_init = System.currentTimeMillis (); Burbuja = matriz.OrdenamientoBurbuja (m, n); time_total = System.currentTimeMillis () - time_init; System.out.println ("\rUtilizando el metodo de ordenamiento Burbuja, tiempo de ejecucion fue : " + time_total + " milisegundos");

el

matriz.LlenarMatriz (m, n); time_init = System.currentTimeMillis (); Seleccion = matriz.OrdenamientoPorSeleccion (m, n); time_total = System.currentTimeMillis () - time_init; System.out.println ("Utilizando el metodo de ordenamiento Seleccion, el tiempo de ejecucion fue : " + time_total + " milisegundos"); matriz.LlenarMatriz (m, n); time_init = System.currentTimeMillis (); Shell = matriz.OrdenamientoPorInsercion (m, n); time_total = System.currentTimeMillis () - time_init; System.out.println ("Utilizando el metodo de ordenamiento ShellSort, el tiempo de ejecucion fue : " + time_total + " milisegundos"); matriz.LlenarMatriz (m, n); time_init = System.currentTimeMillis (); Insercion = matriz.OrdenamientoShellSort (m, n); time_total = System.currentTimeMillis () - time_init; System.out.println ("Utilizando el metodo de ordenamiento Insercion, el tiempo de ejecucion fue : " + time_total + " milisegundos"); matriz.LlenarMatriz (m, n); time_init = System.currentTimeMillis (); QuickSort = matriz.OrdenamientoRapidoQuickSort (m, 0, n * n - 1, n); time_total = System.currentTimeMillis () - time_init;

System.out.println ("Utilizando el metodo de ordenamiento QuickSort, el tiempo de ejecucion fue : " + time_total + " milisegundos"); System.out.println ("\rGracias por ver este programa... ");

} } PRUEBAS 1. Pantalla Inicial

2. Cuando el programa pide la dimencion de la matriz cuadrada

3. Ingresando el valor de la matriz cuadrada : 100 para 1000 numeros aleatorios y pantalla final mostrando los tiempos de ejecucion

CONCLUSIONES

El mtodo de Shell es relativamente sencillo, al comparar elementos no continuos separados por una gran distancia, los elementos que no estn en orden se intercambian. Su mtodo se basa en tomar como salto n/2 (siendo n el nmero de elementos) y luego se va reduciendo a la mitad en cada repeticin hasta que el salto o distancia vale 1 La ordenacin por burbuja consiste en llevar los elementos menores a la izquierda del arreglo o los mayores a la derecha, es la tcnica ms utilizada por su fcil comprensin y programacin aunque suele consumir bastante tiempo de ejecucion en la computadora. El mtodo de bsqueda secuencial compara cada elemento del vector o matriz con el valor a encontrar hasta que este se consiga o se termine de leer el arreglo completo.

Una vez terminado de codificar y analizar los diferentes mtodos de ordenamiento, pudimos darnos cuenta que el mtodo QuickSort es el ms efectivo en funcin del tiempo de ejecucin, pues con arreglos muy grandes los dems mtodos utilizan mucho tiempo para hacer el mismo trabajo.

BIBLIOGRAFIA Algoritmos de Ordenacin y bsqueda Anaya la biblia de java 2 Wikipedia la enciclopedia libre Programacin orientada a objetos con java David Barnes y Michael kulling La bilbia de java 2- shop wiki.com