Beruflich Dokumente
Kultur Dokumente
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.2.3.1 Capitulo 1 ........................................................................................ 5
1.2.3.2 Capitulo 2 ........................................................................................ 6
1.2.3.3 Capitulo 3 ........................................................................................ 6
1.3 Importancia y Justificación ........................................................................ 6
CAPITULO 2 ........................................................................................................... 6
Métodos de Ordenación........................................................................................ 6
2.1 Concepto ...................................................................................................... 6
2.2 Clasificación ................................................................................................ 6
2.2.1 Clasificación Especifica ....................................................................... 6
2.2.1.1 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
Página 2
INTEGRANTES
Página 3
CAPITULO I
Página 4
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.
Página 5
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
CAPITULO 2
Métodos de Ordenación
2.1 Concepto
Página 6
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
Página 7
/*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);
}
2.2.1.1.1.3 En la práctica
Página 8
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
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.
2.2.1.1.2.2 Clasificación
Ordenacion por Inserción Directa
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.
Página 9
De forma gráfica el proceso que sigue el método de inserción directa es el
siguiente
class BusquedaAlgoritmo {
public static int buscar( int [] arreglo, int dato) {
int inicio = 0;
int fin = arreglo.length - 1;
int pos;
while (inicio <= fin) {
Página
10
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.
Página
11
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:
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{
Página
12
int min = i;
if (i != min)
arreglo[i] = arreglo[min];
arreglo[min] = aux;
System.out.print(arreglo[i]+",");
System.out.println();
imprimirLista(lista);
ordenar(lista);
imprimirLista(lista);
2.2.1.1.3.2 Ventajas
ES fácil su implementación,
No requiere memoria adicional
Realiza pocos intercambios
Página
13
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.2 Desarrollo
2.2.1.1.4.3 Ventajas
Página
14
• 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).
2.2.1.1.4.4 Desventajas
Página
15
public static void mergesort(int A[],int izq, int der){
if (izq<der){
int m=(izq+der)/2;
mergesort(A,izq, m);
mergesort(A,m+1, der);
merge(A,izq, m, der);
}
}
Página
16
2.2.1.2.1.3 Ventajas
2.2.1.2.1.4 Desventajas
Página
17
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 de
clasificación por inserción directa.
2.2.1.2.2.2 Desarrollo
Página
18
Se aplica la recursión sobre L1 y L3
Se unen todas las soluciones que darán forma final a la lista L finalmente
ordenada. Como L1 y L3 están ya ordenados, lo único que tenemos que
hacer es concatenar L1, 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) {
Página
19
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.
Página
20
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.
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
Página
21
secuencia tal que represente un orden, el cual puede ser numérico,
alfabético o incluso alfanumérico, ascendente o descendente.
Página
22
Página
23
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.
Página
24
¿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.
Página
25