Algoritmos de ordenacin

Anlisis y Diseo de Algoritmos

Algoritmos de ordenacin
Algoritmos bsicos: (n2) Ordenacin por insercin Ordenacin por seleccin Ordenacin por intercambio directo (burbuja) Algoritmos ms eficientes Mergesort Quicksort Heapsort Shellsort Algoritmos para casos especiales Binsort (ordenacin por urnas)

Introduccin
Supongamos un subconjunto de n elementos X = {e1,,en} de un conjunto referencial Y, X Y. Dentro de Y se define una relacin de orden total (con las propiedades reflexiva, simtrica y transitiva). El objetivo de la ordenacin es encontrar una secuencia de los elementos de X e(1),,e(n) tal que se verifique: e(1) e(n)

Introduccin
Observaciones Los datos pueden ser simples o complejos. El orden se establece de acuerdo al campo clave. Los conjuntos de datos pueden tener duplicados. Si se mantiene el orden relativo de los datos con clave repetida en el conjunto de datos original, el algoritmo se dice que es estable.
3

Introduccin
Tipos de algoritmos de ordenacin Algoritmos de ordenacin interna: En memoria principal (acceso aleatorio) Algoritmos de ordenacin externa: En memoria secundaria (restricciones de acceso).

Aplicaciones
Aplicaciones evidentes: evidentes:
Mostrar los ficheros de un directorio. directorio. Mostrar un listado ordenado del contenido de una base de datos (p.ej. p.ej. listado alfabtico). alfabtico). Ordenar los resultados de una bsqueda en Internet (p.ej (p.ej. . Google PageRank PageRank). ).

Problemas que resultan ms sencillos de resolver con los datos ordenados ordenados: :
Realizar una bsqueda (p.ej. p.ej. bsqueda binaria). binaria). Encontrar la mediana. mediana. Encontrar el par ms cercano cercano. . Identificar outliers / anomalas anomalas. . Detectar duplicados duplicados. .

Aplicaciones
Otras aplicaciones (puede que no tan evidentes) evidentes) :
Compresin de datos. datos. Informtica grfica grfica. . Planificacin de tareas. tareas. Balanceado de carga en un ordenador paralelo. paralelo. Biologa computacional computacional. . Simulacin (p.ej. p.ej. sistemas de partculas). partculas). rbol generador minimal [MST: Minimum Spanning Tree] Gestin de la cadena de suministro [SCM: Supply Chain Management] Recomendaciones de libros en Amazon.com

Ordenacin por seleccin

En cada iteracin, se selecciona el menor elemento del subvector no ordenado y se intercambia con el primer elemento de este subvector subvector: :

Ordenacin por seleccin

void selectionSort (double v[]) { double tmp tmp; ; int i, j, pos_min pos_min; ; int N = v.length v.length; ; for (i (i=0; i<N<N-1; i++) { // Menor elemento del vector v[i..Nv[i..N-1] pos_min = i; for (j=i+1; j<N; j++) if (v[j]<v[pos_min (v[j]<v[pos_min]) ]) pos_min = j; // Coloca el mnimo en v[i] tmp = v[ v[i i]; v[i v[i] = v[ v[pos_min pos_min]; ]; v[pos_min v[pos_min] ] = tmp tmp; ; = } }

Ordenacin por seleccin

void selectionSort (double v[]) { double tmp tmp; ; int i, j, pos_min pos_min; ; int N = v.length v.length; ; for (i (i=0; i<N<N-1; i++) { // Menor elemento del vector v[i..Nv[i..N-1] pos_min = i; for (j=i+1; j<N; j++) if (v[j]<v[pos_min (v[j]<v[pos_min]) ]) pos_min = j; // Coloca el mnimo en v[i] tmp = v[ v[i i]; v[i v[i] = v[ v[pos_min pos_min]; ]; v[pos_min v[pos_min] ] = tmp tmp; ; = } }

Ordenacin por insercin

En cada iteracin, se inserta un elemento del subvector no ordenado en la posicin correcta dentro del subvector ordenado.

10

Ordenacin por insercin

En cada iteracin, se inserta un elemento del subvector no ordenado en la posicin correcta dentro del subvector ordenado.

11

Ordenacin por insercin

void insertionSort (double v[]) { double tmp tmp; ; int i, j; int N = v.length v.length; ; for (i (i=1; i<N; i++) { tmp = v[ v[i i]; for (j= (j=i i; (j>0) && ( (tmp tmp<v[j <v[j-1]); j j---) ) v[j] = v[jv[j-1]; v[j] = tmp tmp; ; } }

12

Mtodo de la burbuja
Ordenacin por intercambio directo IDEA: Los elementos ms ligeros ascienden

13

Mtodo de la burbuja
void bubbleSort (double v[]) { double tmp tmp; ; int i,j i,j; ; int N = v.length v.length; ; for (i = 0; i < N 1; i++) for (j = N 1; j > i; j j---) ) if (v[j] < v[jv[j-1]) { tmp = v v[j]; [j]; v[j] = v[jv[j-1]; v[jv[j -1] = tmp tmp; ; } }

14

Mtodo de la burbuja
Mejora: Usar un centinela y terminar cuando en una iteracin del bucle interno no se produzcan intercambios.
void bubbleSort bubbleSort( (double double[] [] v) { boolean swapped = true; int i, j = 0; double tmp tmp; ; while (swapped swapped) ) { swapped = false; j++; j++ ; for (i = 0; i < v.length - j; i++) if (v[i] > v[i + 1]) { tmp = v[i]; v[i] = v[i + 1]; v[i + 1] = tmp tmp; ; swapped = true; } } }

15

Anlisis de eficiencia
Ordenacin por seleccin N2/2 comparaciones y N intercambios. Ordenacin por insercin N2/4 comparaciones y N2/8 intercambios en media
El doble en el peor caso. Casi lineal para conjuntos casi ordenados.

Ordenacin por burbuja N2/2 comparaciones y N2/2 intercambios en media (y en el peor caso).
Lineal en su versin mejorada si el vector est ordenado.
16

Mergesort
Algoritmo de ordenacin divide y vencers: 1. Dividir nuestro conjunto en dos mitades. 2. Ordenar recursivamente cada mitad. 3. Combinar las dos mitades ordenadas: O(n).

17

Mergesort

A A A A L G

L G L G

G O O H

O R R I

I I H

T T I O

H H M R

M M S S

S S T T Dividir O(1)

Ordenar 2T(n/2) Mezclar O(n)

18

Mergesort
Cmo combinar eficientemente dos listas ordenadas?
Usando un array auxiliar y un nmero lineal de comparaciones: Controlar la posicin del elemento ms pequeo en cada mitad. Aadir el ms pequeo de los dos a un vector auxiliar. Repetir hasta que se hayan aadido todos los elementos.

A A

Optimizacin: InIn-place merge merge ( (Kronrud Kronrud, , 1969)

Cantidad constante de almacenamiento extra.

19

Mergesort
A A G L O R H I M S T

A A

G G

20

Mergesort
A A G G L H O R H I M S T

A A

G G

L H

O I

21

Mergesort
A A G G L H O I R L H I M S T

A A

G G

L H

O I

R L M

22

Mergesort
A A G G L H O I R L M H O I M S T

A A

G G

L H

O I

R L M

H O

I R

23

Mergesort
A A G G L H O I R L M H O I R M S S T

A A

G G

L H

O I

R L M

H O

I R

M S

S T

24

Mergesort
Cmo combinar dos listas ordenadas eficientemente?
Usando un array auxiliar y un nmero lineal de comparaciones: Controlar la posicin del elemento ms pequeo en cada mitad. Aadir el ms pequeo de los dos a un vector auxiliar. Repetir hasta que se hayan aadido todos los elementos.

A A

Optimizacin: InIn-place merge merge ( (Kronrud Kronrud, , 1969)

Cantidad constante de almacenamiento extra.

25

Mergesort

26

Mergesort: Mergesort : Eficiencia

1, n =1 T ( n) = 2T ( n / 2) + n, n > 1
T(n) n 2(n/2)

T(n/2)

T(n/2)

T(n/4)

T(n/4)

T(n/4)

T(n/4) log2n

4(n/4) ...

T(n / 2k) ... T(2) T(2) T(2) T(2) T(2) T(2) T(2) T(2) n/2 (2) 27 n log2n

Mergesort: Mergesort : Eficiencia

1, n =1 T ( n) = 2T ( n / 2) + n, n > 1
Expandiendo la recurrencia:
T ( n) n = = = L = = T ( n / n) n/n log 2 n +1+L+1 1 2 3
log 2 n

2T (n / 2) n T ( n / 2) n/2 T ( n / 4) n/4

+1 +1 +1+1

28

Mergesort: Mergesort : Eficiencia

1, n =1 T ( n) = 2T ( n / 2) + n, n > 1
Usando el mtodo de la ecuacin caracterstica:

ti = T (2i )

ti = 2ti 1 + 2i

ti = c1 2i + c2i 2i

T (n) = c1 2 log 2 ( n ) + c2 log 2 (n)2log 2 ( n ) = c1n + c2 n log 2 (n)

T (n) es O(n log 2 n)

29

Quicksort
1.

Se toma un elemento arbitrario del vector, al que denominaremos pivote (p). Se divide el vector de tal forma que todos los elementos a la izquierda del pivote sean menores que l, mientras que los que quedan a la derecha son mayores que l. Ordenamos, por separado, las dos zonas delimitadas por el pivote.

2.

3.

30

Quicksort
void quicksort (double v[], int izda izda, , int dcha dcha) ) { int pivote; // Posicin del pivote if (izda izda< <dcha dcha) ) { pivote = partir (v, izda izda, , dcha dcha); ); quicksort (v, izda izda, , pivote pivote-1); quicksort (v, pivote+1, dcha dcha); ); } }

Uso:
quicksort (vector, 0, vector.length vector.length-1);

31

Quicksort
Obtencin del pivote Mientras queden elementos mal colocados con respecto al pivote: Se recorre el vector, de izquierda a derecha, hasta encontrar un elemento situado en una posicin i tal que v[i] > p. Se recorre el vector, de derecha a izquierda, hasta encontrar otro elemento situado en una posicin j tal que v[j] < p. Se intercambian los elementos situados en las casillas i y j (de modo que, ahora, v[i] < p < v[j]).
32

Quicksort

33

Quicksort
int partir (double v[], int primero primero, , int ultimo) { // Valor del pivote double pivote = v[primero]; // Variable auxiliar double temporal; int izda = primero+1; int dcha = ultimo; do { // Pivotear Pivotear if (izda < dcha dcha) ) { temporal = v[izda v[izda]; ]; v[izda v[izda] ] = v[ v[dcha dcha]; ]; v[dcha v[dcha] ] = temporal; dcha-dcha --; ; izda++; izda ++; } } while (izda <= dcha dcha); ); // Colocar el pivote en su sitio temporal = v[primero]; v[primero] = v[dcha v[dcha]; ]; v[dcha v[dcha] ] = temporal; // Posicin del pivote return dcha dcha; ; }

while (( ((izda izda<= <=dcha dcha) ) && (v[izda (v[izda]<= ]<=pivote pivote)) )) izda++; izda ++; while ((izda ((izda<= <=dcha dcha) ) && (v[dcha (v[dcha]>pivote)) ]>pivote)) dcha-dcha --; ;

34

Quicksort: Quicksort : Eficiencia

En el peor caso T(n) = T(1) + T(nT(n-1) + cn O(n2) Tamao de los casos equilibrado (idealmente, usando la mediana como pivote) T(n) = 2T(n/2) + cn O(n log n) Promedio

1 n 1 2 n 1 T (n) = [T (n i ) + T (i )] + cn = T (i ) + cn O( n log n) n i =1 n i =1
35

Heapsort
Algoritmo de ordenacin de la familia del algoritmo de ordenacin por seleccin basado en la construccin de un rbol parcialmente ordenado (heap (heap). ).

Heapsort

O(n log n)

36

Heapsort: Heapsort : Eficiencia

1.

Construccin inicial del heap: heap: n operaciones de insercin O(log n) sobre un rbol parcialmente ordenado O(n log n). n). Extraccin del menor/mayor elemento del heap: heap: n operaciones de borrado O(log n) sobre un rbol parcialmente ordenado O(n log n). n).

2.

Por tanto, el heapsort es O(n log n).

37

Shellsort
Mejora del algoritmo de ordenacin por insercin: Compara elementos separados por varias posiciones y, en varias pasadas de saltos cada vez menores, ordena el vector (Donald Shell, 1959).

38

Shellsort
Mejora del algoritmo de ordenacin por insercin: Compara elementos separados por varias posiciones y, en varias pasadas de saltos cada vez menores, ordena el vector (Donald Shell, 1959).

Insercin O(n2)

Shellsort O(nlog2 n)

39

Bucket sort & Binsort

Se divide el array en un conjunto de urnas y cada urna se ordena por separado: O(n2)

Bajo ciertas condiciones (claves entre 0 y NN-1 sin duplicados), la ordenacin se puede hacer en O(n):
void binSort (int int[] [] v) { for (int i = 0; i < v.length v.length; ; i++) while (v[i] != i) { int tmp = v[v[i]]; v[v[i]] = v[i]; v[i] = tmp tmp; ; } }

40

Otros algoritmos
Radix sort Histogram sort Counting sort = ultra sort = math sort Tally sort Pigeonhole sort Bead sort Timsort Smoothsort

41

Resumen
Burbuja

Seleccin

42

Resumen
Insercin

Shellsort

43

Resumen
Heapsort

Quicksort

44

Resumen
Timsort: Timsort : Mergesort + Ordenacin por insercin

45