UNIVERSIDAD SALESIANA DE BOLIVIA

INGENIERIA DE SISTEMAS

TEMA: MÉTODOS DE ORDENAMIENTO

MATERIA: ALGORITMOS AVANZADOS

NOMBRE: PAOLA ANDREA CALLISAYA MITA

CRUZ NINA SOLEDAD

GUTIERREZ PLATA JUAN CARLOS

VELAZCO MERLO MARIA EUGENIA

PARALELO: 5”A1”

DOCENTE: ING. SIMÓN ONOFRE

FECHA: 11/MARZO /2013

LA PAZ – BOLIVIA

INDICE

1. Objetivo

2. Antecedente Conceptual

3. Análisis y diseño de los algoritmos seleccionados

4. Implementación

5. Pruebas

6. Conclusiones

7. Bibliografía

OBJETIVO

El objetivo general del presente proyecto es el de averiguar cuál es el método de ordenamiento, más efectivo en función del tiempo de ejecución en una matriz.

ANTECEDENTE CONCEPTUAL

METODOS DE ORDENAMIENTO

Para poder ordenar una cantidad determinada de números almacenadas en un vector o matriz, existen distintos métodos (algoritmos) con distintas características y complejidad.

Existe desde el método más simple, como el Bubblesort (o Método Burbuja), que son Simples iteraciones, hasta el Quicksort (Método Rápido), que al estar optimizado usando recursión, su tiempo de ejecución es menor y es más efectivo.

METODOS ITERATIVOS

Estos métodos 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 Inserción Selección Shellsort

METODOS RECURSIVOS

Estos métodos son aún más complejos, requieren de mayor atención y conocimiento para ser entendidos. Son rápidos y efectivos, utilizan generalmente la técnica Divide y vencerás, que consiste en dividir un problema grande en varios pequeños para que sea más fácil resolverlos.

Mediante llamadas recursivas a sí mismas, es posible que el tiempo de ejecución y de ordenación sea más óptimo.

Dentó de los algoritmos recursivos encontramos:

• Ordenamiento por Mezclas (merge)

• Ordenamiento Rápido (quick)

ANALISIS

Método de Ordenamiento BurbujaEs el algoritmo de ordenamiento más sencillo de todos, conocido también como método del intercambio directo, el funcionamiento se basa en la revisión de cada elemento de la lista que va a ser ordenada con el elemento siguiente, intercambiando sus posiciones si están en el orden equivocado, para esto se requieren varias revisiones hasta que ya no se necesiten más 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 método es la simple comparación de elementos siendo así el más fácil de implementar.

Método de Ordenación Quick Sort (Ordenamiento Rápido):Es el algoritmo de ordenamiento más eficiente de todos, se basa en la técnica de "Divide y Vencerás", 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 demás 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 implementación 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 más de un elemento. Una vez terminado este proceso todos los elementos estarán ordenados.

Método de ordenación de Selección

La idea básica de esta ordenación es encontrar el elemento menor (o mayor ) de la lista y colocarlo en la primera posición, a continuación , el elemento siguiente menor (o mayor) se lleva a la segunda posición y así sucesivamente hasta que queda ordenado.

En el primer paso se efectúan 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 rápido que el de burbuja.

No hay mejora se el arreglo esta ordenado o desordenado. A pesar de ser fácil de codificar, es improbable que se use esta método, ya que se usan matrices o vectores pequeños.

Método de ordenación de Inserción

Hacer comparaciones, en donde en cada iteración 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 posición correcta.

Ventajas

Fácil de implementar Requerimiento minino de memoria.

Desventaja

Lento Realizar numerosas comparaciones.

Es de utilidad para listas ordenadas o semiordenadas, ya que realiza pocos desplazamientos.

De mejores resultados que el de selección y el de burbuja, en promedio para todos los elementos, el método 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.

Método de Ordenamiento Shell

Este método en si es la versión mejora del método de inserción, se le conoce como de inserción con decrementos.

El ordenamiento por inserción es eficiente se la lista esta casi ordenada, el ordenamiento por inserción es ineficiente porque mueve los valores una posición a la vez.

Las ideas básicas son :

Compara los elementos no contiguos, y separados a una gran distancia, si los elementos no están 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 ordenación funciona como burbuja.

Análisis de eficiencia:

Los requerimientos reales de tiempo para un ordenamiento específico depende del número 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 posición en el arreglo) del arreglo original. El valor K es llamado incremento.

Después de que los primeros K subgrupos han sido ordenados (generalmente utilizando INSERCION DIRECTA), se escoge un nuevo valor de K más pequeño, 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 más pequeño 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 inserción directa.

El método se basa en tomar como salto N/2 (siendo N el número de elementos) y luego se va reduciendo a la mitad en cada repetición 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 aleatoriospublic 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, el tiempo de ejecucion fue : " + time_total + " milisegundos");

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 método de Shell es relativamente sencillo, al comparar elementos no continuos separados por una gran distancia, los elementos que no están en orden se intercambian. Su método se basa en tomar como salto n/2 (siendo n el número de elementos) y luego se va reduciendo a la mitad en cada repetición hasta que el salto o distancia vale 1La ordenación por burbuja consiste en llevar los elementos menores a la izquierda del arreglo o los mayores a la derecha, es la técnica más utilizada por su fácil comprensión y programación aunque suele consumir bastante tiempo de ejecucion en la computadora.El método de búsqueda 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 métodos de ordenamiento, pudimos darnos cuenta que el método QuickSort es el más efectivo en función del tiempo de ejecución, pues con arreglos muy grandes los demás métodos utilizan mucho tiempo para hacer el mismo trabajo.

BIBLIOGRAFIA

Algoritmos de Ordenación y búsqueda Anaya la biblia de java 2 Wikipedia la enciclopedia libre Programación orientada a objetos con java – David Barnes y Michael kulling La bilbia de java 2- shop wiki.com