Métodos de Ordenación
Contenido CAPITULO I ................................................................. .......................................................................................... ........................................... .................. 3 INTEGRANTES 1.1
Introducción .................................................. ........................................................................... ............................................... ...................... 5
1.2
Planteamiento del problema ................................................. ....................................................................... ...................... 5
1.2.1
Objetivos................................................. ......................................................................... ............................................... ...................... 5
1.2.2
Objetivos Generales ................................................... ............................................................................. .......................... 5
1.2.3
Objetivos Específicos ................................................. ........................................................................... .......................... 5
1.3
1.2.3.1
Capitulo 1 .................................................. ........................................................................... ...................................... ............. 5
1.2.3.2
Capitulo 2 .................................................. ........................................................................... ...................................... ............. 6
1.2.3.3
Capitulo 3 .................................................. ........................................................................... ...................................... ............. 6
Importancia y Justificación .................................................. ........................................................................ ...................... 6
CAPITULO 2 ................................................................ ......................................................................................... ........................................... .................. 6 Métodos de Ordenación........................ Ordenación.................................................. ................................................... ...................................... ............. 6 2.1
Concepto .................................................. ............................................................................ .................................................... .......................... 6
2.2
Clasificación ................................................. .......................................................................... ............................................... ...................... 6
2.2.1 2.2.1.1
Clasificación Especifica ................................................. ....................................................................... ...................... 6 Algoritmos de Ordenamiento Lineal ................................................ ................................................ 6
2.2.1.1.1 Ordenación por intercambio o de Burbuja (Buble sort) .............. 6 2.2.1.1.2 Ordenacion por Inserción ( Insertion Sort) .................................. .................................. 9 2.2.1.1.3 Ordenacion por Selección ( Selection Sort) ............................... ............................... 11 2.2.1.1.4 Ordenación por el método de Shell ( Shell Sort ) ...................... 14 2.2.1.2
Algoritmos de ordenamiento Recursivo ........................................ ........................................ 15
2.2.1.2.1 Ordenación por mezclas ( Merge Sort ) ...................................... ...................................... 15 2.2.1.2.2 Ordenación Rápida ( Quick Sort) ................................................ ................................................ 18 CAPITULO III ........................................................... .................................................................................... ............................................. .................... 21 Análisis y Alcances ........................... .................................................... .................................................. ......................................... ................ 21 Resumen ................................................ .......................................................................... .................................................... .................................... .......... 21 4.1
Esquema Comparativo .................................................. ............................................................................ ............................ .. 22
4.2
Conclusiones y Recomendaciones ................................................. ........................................................ ....... 24
INTEGRANTES
Huayhua Huamani, Roberto Huaylla Huillca, Jean Piero Quispe Flores, Yaan carlos Rivera Mamani, Hans Anthony Sarcco Cucho, Jeferson Vera Cuno, Angela Pamela
CAPITULO I
1.1 Introducción
Este tema trata de mirar el mundo que nos rodea e inventar maneras inteligentes para simular ese mundo con código. Ahora, la palabra vector puede significar muchas cosas diferentes. En el lenguaje de programación como el C++ o el java, un vector (es una implementación de una estructura de datos de arreglos que puede cambiar dinámicamente su tamaño).Y Ordenar es simplemente colocar información de una manera especial basándonos en un criterio de ordenamiento. El propósito principal de un ordenamiento es el de facilitar las búsquedas de los registros del conjunto ordenado. Un ordenamiento es conviene usarlo cuándo se requiere hacer una cantidad considerable de búsquedas y es importante el factor tiempo.
Es importante destacar que existen diferentes técnicas de ordenamiento como lo es; El Método Burbuja, que consiste en comparar pares de valores de llaves; Método Selección, el cual consiste en encontrar el menor de todos los elementos del arreglo e intercambiarlo; y por último el Método Intercalación, con el cual se combinan los sub-archivos ordenados en una sola ejecución. 1.2 Planteamiento del problema Cuándo se requiere hacer una cantidad considerable de búsquedas y es importante el factor tiempo. Uso de memoria y otros recursos computacionales. 1.2.1 Objetivos. 1.2.2 Objetivos Generales
Conocer y manejar diferentes métodos de ordenación. Realizar ejecuciones de pruebas de escritorio y en ejecución. Determinar las ventajas y desventajas mediante una aplicación y el tiempo de respuesta. Buscar la eficiencia de los diferentes programas. Es que las personas vean que con ingenio y con materiales simples de consulta se puede crear ideas geniales que no solo nos ayuden a nosotros sino a cientos de personas que requieran de esta información, ya que para crear un mundo de programación es necesario hacer conexiones, en este caso conexiones sociales. 1.2.3 Objetivos Específicos 1.2.3.1 Capitulo 1
Introducir al tema de ordenamiento de vectores 1.2.3.2 Capitulo 2 Elaborar un proyecto acerca del algoritmo de ordenamiento en programación, mediante la utilización de recursos científicos, didácticos y multimedia para estructurar su uso y aplicación adecuada. 1.2.3.3 Capitulo 3 Elaborar secuencialmente comparaciones acerca de los diferentes métodos de ordenación 1.3 Importancia y Justificación
Los métodos de ordenamiento de datos son muy útiles, ya que la forma de arreglar los registros de una tabla en algún orden secuencial de acuerdo a un criterio de ordenamiento, el cual puede ser numérico, alfabético o alfanumérico, ascendente o descendente. Nos facilita las búsquedas de cantidades de registros en un moderado tiempo, en modelo de eficiencia. Mediante sus técnicas podemos colocar listas detrás de otras y luego ordenarlas, como también podemos comparar pares de valores de llaves, e intercambiarlos si no se encuentran en sus posiciones correctas. CAPITULO 2 Métodos de Ordenación 2.1 Concepto
Se refiere a programas los cuales tienen la función de ordenar los diferentes elementos de un array, esto resulta necesario en el campo de la informática, surgiendo así distintos métodos que se mencionaran a continuación 2.2 Clasificación 2.2.1 Clasificación Especifica 2.2.1.1 Algoritmos de Ordenamiento Lineal 2.2.1.1.1 Ordenación por intercambio o de Burbuja (Buble sort) 2.2.1.1.1.1 Historia o Antecedentes
Determinar con exactitud el origen del ordenamiento burbuja es un poco complicado, ya que no existe información precisa sobre su origen. Aunque en 1956 se encuentra expresado en un artículo al que llamaron “ordenamiento por intercambio”. Existe una amplia bibliografía de artículos del año 1962 donde mencionan tipos de ordenamiento basados en este patrón, pero ninguno de ellos usando el nombre como tal.
Sin evidente origen definitivo, el nombre "burbuja“ se cierran sus orígenes mediante la consulta de los primeros artículos de revistas así como textos profesionales y pedagógicos de esta época. 2.2.1.1.1.2
Funcionamiento
Funciona de la siguiente manera: Se va comparando cada elemento del arreglo con el siguiente; si un elemento es mayor que el que le sigue, entonces se intercambian; esto producirá que en el arreglo quede como su último elemento, el más grande. Este proceso deberá repetirse recorriendo todo el arreglo hasta que no ocurra ningún intercambio. Los elementos que van quedando ordenados ya no se comparan. "Baja el más pesado". Consiste en comparar pares de elementos adyacentes e intercambiarlos entre sí hasta que estén todos ordenados.
Sea un array de 6 números de empleados:
{40, 21, 4, 9, 10,35}:
Primera pasada: {21, 40, 4, 9, 10,35} <-- Se cambia el 21 por el 40. {21, 4, 40, 9, 10,35} <-- Se cambia el 40 por el 4. {21, 4, 9, 40, 10,35} <-- Se cambia el 9 por el 40. {21, 4, 9, 10, 40,35} <-- Se cambia el 40 por el 10. {21, 4, 9, 10, 35,40} <-- Se cambia el 35 por el 40. Segunda pasada: {4, 21, 9, 10, 35,40} <-- Se cambia el 21 por el 4. {4, 9, 21, 10, 35,40} <-- Se cambia el 9 por el 21. {4, 9, 10, 21, 35,40} <-- Se cambia el 21 por el 10. Ya están ordenados, pero para comprobarlo habría que acabar esta segunda comprobación y hacer una tercera. El método de Ordenamiento por intercambio en Java es el siguiente:
public class burbuja { public static void main(String arg[]) throws IOException { /*creacion del objeto para leer por teclado*/ BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
/*ingreso del tamaño de arreglos*/ System.out.print("\n Ingrese Numero de Datos a Ingresar : "); int tam = Integer.parseInt(in.readLine()); /*creacion del arreglo*/ int arr[] = new int[tam]; System.out.println(); /*lectura del arreglo*/ int j = 0; for (int i = 0 ; i < arr.length;i++) { j+=1; System.out.print("Elemento " + j + " : "); arr[i] = Integer.parseInt(in.readLine()); } burbuja(arr); } static void burbuja(int arreglo[]) { for(int i = 0; i < arreglo.length - 1; i++) { for(int j = 0; j < arreglo.length - 1; j++) { if (arreglo[j] < arreglo[j + 1]) { int tmp = arreglo[j+1]; arreglo[j+1] = arreglo[j]; arreglo[j] = tmp; } } } for(int i = 0;i < arreglo.length; i++) { System.out.print(arreglo[i]+"\n"); } } }
2.2.1.1.1.3
En la práctica
El ordenamiento de burbuja es asintóticamente equivalente en tiempos de ejecución con el ordenamiento por inserción en el peor de los casos, pero ambos algoritmos difieren principalmente en la cantidad de intercambios que son necesarios. Resultados experimentales como los descubiertos por Astrachan han demostrado que el ordenamiento por inserción funciona considerablemente mejor incluso con listas aleatorias. Por esta razón, muchos libros de algoritmos modernos evitan usar el ordenamiento de burbuja, reemplazándolo por el ordenamiento por inserción.
El ordenamiento de burbuja interactúa vagamente con el hardware de las CPU modernas. Requiere al menos el doble de escrituras que el ordenamiento por inserción, el doble de pérdidas de caché, y asintóticamente más predicción de saltos. Varios experimentos de ordenamiento de cadenas en Java hechos por Astrachan muestran que el ordenamiento de burbuja es 5 veces más lento que el ordenamiento por inserción, y 40% más lento que el ordenamiento por selección.
2.2.1.1.1.4 Ventajas Es bastante sencillo En un código reducido Se realiza el ordenamiento Eficaz 2.2.1.1.1.5 Desventajas
Consume bastante tiempo de computadora Requiere muchas lecturas/escrituras en memoria
2.2.1.1.2 Ordenacion por Inserción ( Insertion Sort) 2.2.1.1.2.1 Historia o Antecedentes
Es una manera muy natural de ordenar para un ser humano, y puede usarse fácilmente para ordenar un mazo de cartas numeradas en forma arbitraria. Requiere O(n²) operaciones para ordenar una lista de n elementos. Inicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado. Después, cuando hay k elementos ordenados de menor a mayor, se toma el elemento k+1 y se compara con todos los elementos ya ordenados, deteniéndose cuando se encuentra un elemento menor (todos los elementos mayores han sido desplazados una posición a la derecha) o cuando ya no se encuentran elementos (todos los elementos fueron desplazados y este es el más pequeño). En este punto se inserta el elemento k+1 debiendo desplazarse los demás elementos.
2.2.1.1.2.2 Clasificación Ordenacion por Inserción Directa
El método de ordenación por inserción directa consiste en recorrer todo el array comenzando desde el segundo elemento hasta el final. Para cada elemento, se trata de colocarlo en el lugar correcto entre todos los elementos anteriores a él o sea entre los elementos a su izquierda en el array. Dada una posición actual p, el algoritmo se basa en que los elementos A[0], A[1], ..., A[p-1] ya están ordenados.
De forma gráfica el proceso que sigue el método de inserción directa es el siguiente
El método de Ordenamiento por inserción directa en Java es el siguiente: public static void insercionDirecta(int A[]){ int p, j; int aux; for (p = 1; p < A.length; p++){ // desde el segundo elemento hasta aux = A[p]; // el final, guardamos el elemento y j = p - 1; // empezamos a comprobar con el anterior while ((j >= 0) && (aux < A[j])){ // mientras queden posiciones y el // valor de aux sea menor que los A[j + 1] = A[j];
// de la izquierda, se desplaza a
j--;
// la derecha
} A[j + 1] = aux; // colocamos aux en su sitio } }
Ordenacion por Insercion Binaria
class BusquedaAlgoritmo { public static int buscar( int [] arreglo, int dato) {
int inicio = 0; int fin = arreglo.length - 1; int pos; while (inicio <= fin) {
pos = (inicio+fin) / 2; if ( arreglo[pos] == dato ) return pos; else if ( arreglo[pos] < dato ) { inicio = pos+1; } else { fin = pos-1; } } return -1; } }
2.2.1.1.2.3 Ventajas Es un algoritmo sencillo de entender y de codificar. Si el tamaño de la entrada es N, entonces el orden del tiempo de ejecución, para elpeor caso es O(N2); Si la entrada esta "casi ordenada", el algoritmo se ejecuta mucho más rápidamente. Esta velocidad tiende a un tiempo O(N), peor caso que se cumple cuando la entrada está totalmente ordenada. Es por la propiedad anterior que este algoritmo, a pesar de no ser el más rápido para entradas grandes, suele usarse de la siguiente manera: Se semi ordena la entrada con algún otro algoritmo más rápido y más adecuado para entradas grandes. Luego, cuando tenemos la entrada "casi ordenada" usamos este algoritmo. La velocidad de ejecución será muy buena por dos razones: su tiempo de ejecución tiende a O(N) con entradas "casi ordenadas" (lo cual es un tiempo excelente), y la simpleza de su implementación hará que se ejecute más rápido que otros algoritmos más complejos.
2.2.1.1.2.4 Desventajas No funciona tan bien como otros algoritmos mejores de ordenamiento. Con n al cuadrado pasos requeridos para cada n elemento a ser ordenado, este algoritmo no funciona bien con una lista grande. Por lo tanto, este sólo es útil cuando se ordena una lista de pocos elementos. 2.2.1.1.3 Ordenacion por Selección ( Selection Sort)
Este algoritmo trabaja seleccionando el dato más pequeño a ser ordenado que aún está en la lista, y luego haciendo un intercambio con el elemento en la siguiente posición. 2.2.1.1.3.1
Desarrollo
Su funcionamiento es el siguiente:
Buscar el mínimo elemento de la lista
Intercambiarlo con el primero
Buscar el siguiente mínimo en el resto de la lista
Intercambiarlo con el segundo
Y en general:
Buscar el mínimo elemento entre una posición i y el final de la lista
Intercambiar el mínimo con el elemento de la posición i
Ejemplo, si tenemos el array {40, 21, 4, 9, 10,35}, los pasos a seguir son : {4, 21, 40, 9, 10,35} <-- Se coloca el 4, el más pequeño, en primera posición: se cambia el 4 por el 40. {4, 9, 40, 21, 10,35} <-- Se coloca el 9, en segunda posición: se cambia el 9 por el 21. {4, 9, 10, 21, 40,35} <-- Se coloca el 10, en tercera posición: se cambia el 10 por el 40. {4, 9, 10, 21, 40,35} <-- Se coloca el 21, en tercera posición: ya está colocado. {4, 9, 10, 21, 35,40} <-- Se coloca el 35, en tercera posición: se cambia el 35 por el 40.
class seleccion{ public static void ordenar(int[] arreglo){ int contador = 1;//solo util para contar las comparaciones for (int i = 0; i < arreglo.length - 1; i++) {
int min = i; for (int j = i + 1; j < arreglo.length; j++) { //System.out.println("Comparación #" + contador); contador++; if (arreglo[j] < arreglo[min]){ min = j; } } if (i != min) { int aux= arreglo[i]; arreglo[i] = arreglo[min]; arreglo[min] = aux; } } } public static void imprimirLista(int[] arreglo) { for(int i = 0; i < arreglo.length;i++) { System.out.print(arreglo[i]+","); } System.out.println(); } public static void main(String[] args){ int lista[] = {40,21,4,9,10,35}; System.out.print("Lista desordenada: "); imprimirLista(lista); ordenar(lista); System.out.print("Lista ordenada: "); imprimirLista(lista); } }
2.2.1.1.3.2 Ventajas ES fácil su implementación, No requiere memoria adicional Realiza pocos intercambios
Tiene un rendimiento constante
2.2.1.1.3.3 Desventajas Es lento y poco eficiente cuando se utiliza listas grandes o medianas(realiza numerosas comparaciones)
2.2.1.1.4 Ordenación por el método de Shell ( Shell Sort ) 2.2.1.1.4.1 Historia o Antecedentes
El método de ordenación Shell debe su nombre a su inventor, Donald Shell, y fue uno de los primeros algoritmos de ordenamiento en romper la barrera del tiempo cuadrático. 2.2.1.1.4.2
Desarrollo
El método Shell de ordenación en Java para ordenar un array A de enteros es el siguiente: public static void shell(int A[]){ int salto, aux, i; boolean cambios; for(salto=A.length/2; salto!=0; salto/=2){ cambios=true; while(cambios){ // Mientras se intercambie algún elemento cambios=false; for(i=salto; i< A.length; i++) // se da una pasada if(A[i-salto]>A[i]){ // y si están desordenados aux=A[i]; // se reordenan A[i]=A[i-salto]; A[i-salto]=aux; cambios=true; // y se marca como cambio. } } } }
2.2.1.1.4.3
Ventajas
Cualquier algoritmo de ordenación que intercambia elementos adyacentes (como los algoritmos burbuja, selección o inserción) tiene un tiempo promedio de ejecución de orden cuadrático (n2). El método Shell mejora este tiempo comparando cada elemento con el que está a un cierto número de posiciones llamado salto, en lugar de compararlo con el el que está justo a su lado. Este salto es constante, y su valor inicial es N/2 (siendo N el número de elementos, y siendo división entera). •
Es una mejora del método de inserción directa, utilizado cuando el • array tiene un gran número de elementos. •
No requiere memoria adicional.
•
Mejor rendimiento que el método de Inserción clásico
•
veces más rápido que bubble sort.
•
2 veces más rápido que insertion sort. 2.2.1.1.4.4
Desventajas
Implementación algo confusa. • Realiza numerosas comparaciones e intercambios. • • Shell Sort es significativamente mas lento que merge, heap y quick sort. 2.2.1.2 Algoritmos de ordenamiento Recursivo 2.2.1.2.1 Ordenación por mezclas ( Merge Sort ) 2.2.1.2.1.1 Historia o Antecedentes
El método MergeSort es un algoritmo de ordenación recursivo con un número de comparaciones entre elementos del array mínimo. Su funcionamiento es similar al Quicksort, y está basado en la técnica divide y vencerás. 2.2.1.2.1.2
Desarrollo
De forma resumida el funcionamiento del método MergeSort es el siguiente:
Si la longitud del array es menor o igual a 1 entonces ya está ordenado. El array a ordenar se divide en dos mitades de tamaño similar. Cada mitad se ordena de forma recursiva aplicando el método MergeSort. A continuación las dos mitades ya ordenadas se mezclan formando una secuencia ordenada.
La ordenación mergesort se puede implementar en Java de la siguiente forma:
public static void mergesort(int A[],int izq, int der){ if (izq
El método ordena un array A de enteros desde la posición izq hasta la posición der. En la primera llamada al método recibirá los valores izq = 0, der = ELEMENTOS-1. Primero se calcula el elemento central m. A continuación la primera parte del array, desde izq hasta m y la segunda parte del array, desde m+1 hasta der, se mezclan mediante llamadas recursivas al método mergesort. La recursión termina cuando izq == der, es decir, cuando un subarray contiene solamente un elemento. La operación principal de mezcla la realiza el método merge. Este método se puede implementar de varias formas, la más usual es la siguiente:
public static void merge(int A[],int izq, int m, int der){ int i, j, k; int [] B = new int[A.length]; //array auxiliar for (i=izq; i<=der; i++) //copia ambas mitades en el array auxiliar B[i]=A[i]; i=izq; j=m+1; k=izq; while (i<=m && j<=der) //copia el siguiente elemento más grande if (B[i]<=B[j]) A[k++]=B[i++]; else A[k++]=B[j++]; while (i<=m) //copia los elementos que quedan de la A[k++]=B[i++]; //primera mitad (si los hay) }
De forma gráfica podemos representar el funcionamiento del algoritmo de la siguiente forma:
2.2.1.2.1.3
Ventajas
Método de ordenamiento estable mientras la función de mezcla sea implementada correctamente. Muy estable cuando la cantidad de registros a acomodar es de índice bajo, en caso contrario gasta el doble del espacio que ocupan inicialmente los datos. Efectivo para conjunto de datos a los que se puede acceder secuencialmente (arreglos, vectores, etc.)
2.2.1.2.1.4
Desventajas
Está definido recursivamente. Si se deseara implementarla no recursivamente se tendría que emplear una pila y se requeriría un espacio adicional de memoria para almacenarla.
2.2.1.2.2 Ordenación Rápida ( Quick Sort) 2.2.1.2.2.1 Historia o Antecedentes
Este algoritmo nace como una necesidad para reunir datos estadísticos.
1945- Zuse desarrolla un programa clasificación por inserción directa.
de
1946- John Mauchly mayor velocidad en procesos de clasificación. Demostró que a clasificación es útil con los cálculos numéricos.
A partir de aquí se desarrollan los algoritmos de clasificación binaria y por inserción directa. Charles Antony Richard Hoare 1960 - Sir Charles Antony Richard Hoare, Tony Hoare o CAR Hoare, nacido 11 de enero 1934 es un científico informático británico, probablemente el más conocido para el desarrollo en 1960 de Quicksort (o Hoaresort),uno de los más utilizados algoritmos de ordenación del mundo.
2.2.1.2.2.2
Desarrollo
Se basa en la técnica divide y vencerás , que consiste en ir subdividiendo el array en arrays más pequeños, y ordenar éstos. Para hacer esta división, se toma un valor del array como pivote, y se mueven todos los elementos menores que este pivote a su izquierda, y los mayores a su derecha. A continuación se aplica el mismo método a cada una de las dos partes en las que queda dividido el array.
2.2.1.2.2.2.1 Funcionamiento Se elige un elemento v de la lista L de elementos al que se le llama pivote. Se particiona la lista L en tres listas: L1 - que contiene todos los elementos de L menos v que sean menores o iguales que v L2 - que contiene a v L3 - que contiene todos los elementos de L menos v que sean mayores o iguales que v
Se aplica la recursión sobre L 1 y L3 Se unen todas las soluciones que darán forma final a la lista L finalmente ordenada. Como L 1 y L3 están ya ordenados, lo único que tenemos que hacer es concatenar L 1, L2 y L3
Aunque este algoritmo parece sencillo, hay que implementar los pasos 1 y 3 de forma que se favorezca la velocidad de ejecución del algoritmo. Suponiendo que tomamos como pivote el primer elemento, el método Java Quicksort que implementa este algoritmo de ordenación para ordenar un array de enteros se presenta a continuación. Los parámetros izq y der son el primer y último elemento del array a tratar en cada momento. El método ordena un array A de enteros desde la posición izq hasta la posición der. En la primera llamada recibirá los valores izq = 0, der = ELEMENTOS-1. public static void quicksort(int A[], int izq, int der) { int int int int
pivote=A[izq]; // tomamos primer elemento como pivote i=izq; // i realiza la búsqueda de izquierda a derecha j=der; // j realiza la búsqueda de derecha a izquierda aux;
while(ipivote) j--; // busca elemento menor que pivote if (i
Una interpretación gráfica a considerar sería:
han
La elección del pivote determinará la eficiencia de este algoritmo ya que determina la partición del array. Si consideramos que el array está desordenado, podemos elegir el primer elemento y el algoritmo funcionaría de forma eficiente. Pero si el array está casi ordenado, elegir el primer elemento como pivote sería una mala solución ya que obtendríamos un subarray muy pequeño y otro muy grande. Por la misma razón, elegir el último elemento del array como pivote también es una mala idea. Pretendemos conseguir que el tamaño de los subarrays sea lo más parecido posible.
Una alternativa a elegir el primer elemento es elegir como pivote un elemento al azar de entre todos los del array. Otra estrategia es calcular la mediana de los valores de la izquierda, centro y derecha del vector. Por ejemplo para el vector 9 8 1 6 10 2 3, se calcula la mediana de los elementos que ocupan el primer lugar, el último y el centro o sea 9 3 6. La mediana es 6 que determinaría las particiones {1 3 2} {6} {8 10 9}. 2.2.1.2.2.2.2 Características especiales
En la práctica, es el algoritmo de ordenación más rápido conocido, su tiempo de ejecución promedio es O(n log (n)), cabe resaltar que en el peor de los casos O(n2), caso altamente improbable. El hecho de que sea más rápido que otros algoritmos de ordenación con tiempo promedio de O(n log (n)) ( como SmoothSort o HeapSort ) viene dado por que QuickSort realiza menos operaciones ya que el método utilizado es el de partición. 2.2.1.2.2.3
Ventajas
Muy rápido. No requiere memoria adicional. 2.2.1.2.2.4 Desventajas Implementación un poco más complicada. Recursividad (utiliza muchos recursos). Mucha diferencia entre el peor y el mejor caso.
CAPITULO III Análisis y Alcances Resumen Por ordenar se entiende el proceso de reorganizar un conjunto de objetos en una cierta secuencia de acuerdo a un criterio especificado. En general, el objetivo de este proceso es facilitar la posterior búsqueda de elementos en el conjunto ordenado.
Existen múltiples ejemplos reales de conjuntos que requieren ser ordenados: la guía telefónica, índices de libros, ficheros de bibliotecas, diccionarios, ficheros de diverso tipo en oficinas, actas de exámenes, etc. Debido a que las estructuras de datos son utilizadas para almacenar información, para poder recuperar esa información de manera eficiente es deseable que aquella esté ordenada. Existen varios métodos para ordenar las diferentes estructuras de datos básicas. En general los métodos de ordenamiento no son utilizados con frecuencia, en algunos casos sólo una vez. Hay métodos muy simples de implementar que son útiles en los casos en dónde el número de elementos a ordenar no es muy grande (ej, menos de 500 elementos). Por otro lado hay métodos sofisticados, más difíciles de implementar pero que son más eficientes en cuestión de tiempo de ejecución. Los métodos sencillos por lo general requieren de aproximadamente n x n pasos para ordenar n elementos. Los métodos simples son: insertion sort (o por inserción directa) selection sort, bubble sort, y shellsort, en dónde el último es una extensón al insertion sort, siendo más rápido. Los métodos más complejos son el quick-sort, el heap sort, radix y address-calculation sort. El ordenar un grupo de datos significa mover los datos o sus referencias para que queden en una
secuencia tal que represente un orden, el cual puede ser numérico, alfabético o incluso alfanumérico, ascendente o descendente. Se ha dicho que el ordenamiento puede efectuarse moviendo los registros con las claves. El mover un registo completo implica un costo, el cual se incrementa conforme sea mayor el tamaño del registro. Es por ello que es deseable evitar al máximo el movimiento de los registros. Una alternativa es el crear una tabla de referencias a los registros y mover las referencias y no los datos. A continuación se mostrarán los métodos de ordenamiento empezando por el más sencillo y avanzando hacia los mas sofisticados La eficiencia de los algoritmos se mide por el número de comparaciones e intercambios que tienen que hacer, es decir, se toma n como el número de elementos que tiene el arreglo a ordenar y se dice que un algoritmo realiza O(n2) comparaciones cuando compara n veces los n elementos, n x n = n2. 4.1 Esquema Comparativo
4.2 Conclusiones y Recomendaciones Eligiendo el más adecuado. No existe EL ALGORITMO de ordenamiento. Sólo existe el mejor para cada caso particular. Debe conocerse a fondo el problema a resolver, y aplicar el más adecuado. Aunque hay algunas preguntas que pueden ayudar a elegir: ¿Qué grado de orden tendrá la información que va a manejar? Si la información va a estar casi ordenada y no desea complicarse, un algoritmo sencillo como el ordenamiento burbuja será suficiente. Si por el contrario los datos van a estar muy desordenados, un algoritmo poderoso como Quicksort puede ser el más indicado. Y si no puede hacer una presunción sobre el grado de orden de la información, lo mejor será elegir un algoritmo que se comporte de manera similar en cualquiera de estos dos casos extremos.
¿Qué cantidad de datos va a manipular? Si la cantidad es pequeña, no es necesario utilizar un algoritmo complejo, y es preferible uno de fácil implementación. Una cantidad muy grande puede hacer prohibitivo utilizar un algoritmo que requiera de mucha memoria adicional. ¿Qué tipo de datos quiere ordenar? Algunos algoritmos sólo funcionan con un tipo específico de datos (enteros, enteros positivos, etc.) y otros son generales, es decir, aplicables a cualquier tipo de dato. ¿Qué tamaño tienen los registros de la lista? Algunos algoritmos realizan múltiples intercambios (burbuja, inserción). Si los registros son de gran tamaño estos intercambios son más lentos.
