OrdenamientosJos Galaviz

Seleccin1. Seleccion(arreglo)2. for j = {0, ,n-2} do3. min arreglo[j]4. idxmin j5. for i = {j+1, , n-1} do6. if arreglo[i] < min then7. min arreglo[i]8. idxmin i9. endif

10. endfor11. if j idxmin then12. swap(arreglo, j, idxmin)13. endif14. endfor15. end.

Anlisis de seleccin n-j-1 repeticiones del ciclo 5-10 (se repetira

n-1 veces, pero empieza en j+1, se salt las primeras j)

Con j desde 0 a n-2, ciclo 2-14

Burbuja

1. Burbuja(arreglo)2. for j = {0, ,n-2} do3. for i = {n-1, , j+1} do4. if arreglo[i] < arreglo[i-1] then5. swap(arreglo, i, i-1)6. endif7. endfor8. endfor9. end.

Anlisis de burbuja

n-j-1 repeticiones del ciclo 3-7 Con j desde 0 a n-2, ciclo 2-8

Insercin1. Insercion(arreglo)2. for i = {1, ,n-1} do3. tmp arreglo[i]4. j i - 15. while ((j 0) (arreglo[j] > tmp)) do6. arreglo[j+1] arreglo[j]7. j j - 18. endwhile9. arreglo[j+1] tmp

10. endfor11. end.

Anlisis de insercin Peor caso (cota superior): elementos en

orden decreciente (justo al revs de como los queremos).

j desde i-1 hasta 0 (i veces) del ciclo 5-8 Con i desde 1 a n-1, ciclo 2-10

Shell1. Shell(arreglo)2. for dist = {n/2, ,n/2k, ,1} do3. for i = {dist, , n - 1} do4. tmp arreglo[i]5. j i - dist6. while ((j 0) (tmp < arreglo[j])) do7. arreglo[j + dist] arreglo[j]8. j j - dist9. endwhile

10. arreglo[j + dist] tmp11. endfor12. endfor13. end.

Anlisis de Shell Peor caso (cota superior): para ninguna

distancia mayor que uno se hace nada. Entonces es el ordenamiento por insercin. j desde i-1 hasta 0 (i veces) del ciclo 6-9 Con i desde 1 a n-1, ciclo 3-11

Ejemplo

Comparacin

Particin de quicksort1. Particion(arreglo, inf, sup)2. pivote arreglo[(inf + sup)/2]3. do4. while (pivote > arreglo[inf]) do5. inf inf + 16. endwhile7. while (pivote < arreglo[sup]) do8. sup sup - 19. endwhile

10. if (inf sup) then 11. swap(arreglo, inf, sup)12. inf inf + 113. sup sup - 114. endif15. while (inf sup)16. return {inf, sup}17. end.

Quicksort

1. Quicksort(arreglo, inf, sup)2. if (inf < sup) then3. i inf4. j sup5. Particion(arreglo, i, j)6. Quicksort(arreglo, inf, j)7. Quicksort(arreglo, i, sup)8. endif9. end.

Anlisis de Quicksort

En general depende de la eleccin del pivote el que se haga una particin lo ms equitativa posible.

Lo que garantizara un rbol de descenso lo ms perfecto posible, de mnima altura (log n).

Por la ley de los grandes nmeros podramos decir que el valor esperado del conjunto es la media.

Anlisis de Quicksort

Cuantas comparaciones se hacen? En cada piso del rbol exactamente n en total.

Y esperamos tener log n pisos. As que debera estar cerca de O(n log n)

En el peor caso se elige como pivote siempre el mnimo del sub arreglo y entonces se convierte en el ordenamiento por seleccin:

O(n2)

Mezclar con orden (1 / 2)1. Merge(arreglo, inf, m, sup)2. i inf3. d m + 14. r 05. while ((i m) (d sup)) do6. if (arreglo[i] arreglo[d]) then7. resul[r] arreglo[i]8. i i + 19. else

10. resul[r] arreglo[d]11. d d + 112. endif13. r r + 114. endwhile

Mezclar con orden (2 / 2)15. while (i m) do16. resul[r] arreglo[i]17. r r + 118. i i + 119. endwhile20. while (d sup) do21. resul[r] arreglo[d]22. r r + 123. d d + 124. endwhile25. idx 026. for i = {inf, , sup} do27. arreglo[i] = resul[idx]28. endfor29. end.

Mergesort

1. Mergesort(arreglo, inf, sup)2. if (inf < sup) then3. m (inf + sup) / 24. Mergesort(arreglo, inf, m)5. Mergesort(arreglo, m+1, sup)6. Merge(arreglo, inf, m, sup)7. endif8. end.

Anlisis de Mergesort 1

Cuantas comparaciones de tarda Mergesort para una entrada de tamao n?

Digamos T(n). Para resolver el caso de complejidad n, se

resuelven dos (2) casos de complejidad n/2. Y luego se mezclan los subarreglo

ordenados en tiempo proporcional a n.

Anlisis de Mergesort 2

de donde:

Anlisis de Mergesort 3 O sea el tiempo para resolver con n es el

de la mitad entre la mitad ms uno. O sea el tiempo para resolver con n es el

de la cuarta parte entre la cuarta parte ms dos.

Si llegamos a la n-sima parte (con n

potencia de dos para que sea fcil). Cuantos unos hemos aadido?

1 con n/2 2 con n/4 k con n/2k

log n en la n-sima parte.

Anlisis de Mergesort 4

de donde:

como el caso promedio de Quicksort.Mergesort en el peor caso toma lo mismo que en promedio n log n.

Quicksort Vs. Mergesort

Mergesort: Experimentalmente, en su peor caso hace un 39%

menos de comparaciones que Quicksort en su caso promedio.

Pero usa ms memoria, necesita O(n) celdas para guardar los subarreglos ordenados, es difcil modificarlo para que lo haga in situ.

Es estable: los elementos de igual llave, preservan su orden relativo antes y despus de Mergesort. Quicksort no es estable.

Qu es ordenar?

Para un conjunto de n elementos en un dominio con un orden total definido.

Determinar cul de las n! permutaciones es la que tiene a los elementos en orden creciente de izquierda a derecha.

rbol de decisin

Espacio de bsqueda0. {[abc],[acb],[bac],[bca],[cab],[cba]}1.

a. S: {[abc],[acb],[cab]}b. No: {[bac],[bca],[cba]}

2.a. SSi: {[abc]}b. SNo: {[acb],[cab]}c. NoS: {[bac],[bca]}d. NoNo: {[cba]}

3.a. SNoS: {[acb]}b. SNoNo: {[cab]}c. NoSS: {[bac]}d. NoSNo: {[bca]}

Anlisis

Es un rbol binario con n! hojas. Para llegar a un ordenamiento se debe descender por

el rbol. Desde la raz (no se nada, mi dominio de bsqueda es

todas las permutaciones). Hasta una hoja (conozco la secuencia ordenada, es la

nica posibilidad que queda). Cada nodo del camino es una comparacin. A lo ms tantas como la altura del rbol. En un rbol binario de n! hojas la altura es, al menos,

log2 n!

Cota superior

As que la altura del rbol es, al menos:

Cota inferior

Por otro lado:

Es decir:

de donde:

entonces:

Finalmente, ambas cotas:

Stirling

Otra forma de verlo es usando la frmula de Stirling.

public static

public static

public static

public static

private static

private static

private static

private static

private static

private static