Ordenamiento de un arreglo. Algoritmos y Estructuras de Datos I. Algoritmo downsort. Upsort vs downsort

Transcripción

1 Ordenamiento de un arreglo Algoritmos y Estructuras de Datos I Primer cuatrimestre de 2014 Departamento de Computación - FCEyN - UBA Programación imperativa - clase 8 Algoritmos de ordenamiento II Tenemos un arreglo de un tipo T con una relación de orden ( ) y queremos modificar el arreglo para que sus elementos queden en orden creciente. problema sort<t> (a : [T]) { requiere 1 a ; modifica a; asegura mismos(a, pre(a)) ordenado(a); Adoptamos como estrategia que modificamos el arreglo permutando elementos, para garantizar que nuestro algoritmo no pierde ningún elemento del arreglo. Conocemos el algoritmo upsort, con complejidad O(n 2 ). 1 2 Algoritmo downsort Upsort vs downsort // invariante I : 0 actual a 1 mismos(a, pre(a)) ordenado(a(actual.. a )) actual < a 1 ( x a[0..actual]) x a actual+1 Podemos considerar un algoritmo similar, que en cada paso busque el mínimo elemento y lo ubique al principio de la parte no ordenada del arreglo. Este algoritmo se llama downsort o selection sort. // invariante I : 0 actual a 1 mismos(a, pre(a)) ordenado(a[0..actual)) actual > 0 ( x a[actual.. a )) x a actual 1 Los invariantes de ambos algoritmos provienen de reemplazar distintas constantes en la postcondición del problema: asegura mismos(a, pre(a)) ordenado(a[0.. a )); Si reemplazamos el lado izquierdo en a[0.. a ), tenemos el invariante de upsort (más una condición adicional): I : 0 actual a 1 mismos(a, pre(a)) ordenado(a(actual.. a ))... Si reemplazamos el lado derecho en a[0.. a ), tenemos el invariante de downsort: I : 0 actual a 1 mismos(a, pre(a)) ordenado(a[0..actual))

2 Algoritmo insertion sort Algoritmo insertion sort Consideremos qué sucede ahora si eliminamos la última condición del invariante de downsort: I : 0 i a mismos(a, pre(a)) ordenado(a[0..i)) La función variante es v = n i. Qué dice este invariante? Se puede implementar un algoritmo de ordenamiento sobre esta base? while( i < a.length ) { I : 0 i < a mismos(a, pre(a)) ordenado(a[0..i)) j = i; while( j>0 && a[j] < a[j-1] ) { swap(a, j, j-1); --j; E : 0 i a mismos(a, pre(a)) ordenado(a[0..i + 1)) ++i; 5 6 Supongamos que tenemos la siguiente hipótesis adicional: problema dfp(a : [Z]) { requiere a 1; requiere ( i [0.. a )) 0 a i 2; modifica a; asegura mismos(a, pre(a)) ordenado(a); Reglas: Solamente podemos modificar el arreglo haciendo swaps, y el algoritmo debe tener complejidad O(n). Observar que la postcondición se puede escribir de la siguiente forma equivalente (abusando levemente de la notación): asegura mismos(a, pre(a)) ( i, j [0.. a ), i j) a[0..i) = 0 a[i..j) = 1 a[j.. a ) = 2 En esta expresión, definimos a[d, h) = x ( i [d, h)) a i = x En forma gráfica: i j 7 8

3 El invariante proviene de relajar la variable j: I: mismos(a, pre(a)) 0 i j k a En forma gráfica: 0 1? 2 El invariante es equivalente a la postcondición si j=k, y entonces tenemos la guarda del ciclo. Para inicializar trivialmente el invariante, hacemos: j = 0; k = a.length; j = 0; k = a.length; while( j!= k ) { I B :... if( a[j] == 0 ) I... j k a j = 0 else if( a[j] == 1 ) I... j k a j = 1 else if( a[j] == 2 ) I... j k a j = Caso 1: a j = E 1 : mismos(a, pre(a)) 0 i j < k a a j = 1 E 2 : a = a@e 1 j = j@e i = i@e 1 k = k@e 1 implica 0 i j k a implica a[i..j 1) = 1 a j 1 = 1 implica a[i..j 1] = 1 implica I I: mismos(a, pre(a)) 0 i j k a Caso 2: a j = E 1 : mismos(a, pre(a)) 0 i j < k a a j = 2 swap(a,j,k-1); E 2 : a j = a k 1 a k 1 = a 1 ( t [0.. a ), t j, k 1)a t = a 1 i = i@e 1 j = j@e 1 k = k@e 1 implica a k 1 = 2 mismos(a, pre(a)) implica a[0..i) = 0 a[i..j) = 1 a[k 1.. a ) =

4 Caso 2: a j = 2 Caso 3: a j = E 2 : mismos(a, pre(a)) 0 i j < k a a[0..i) = 0 a[i..j) = 1 a[k 1.. a ) = 2 --k; E 3 : a = a@e 2 i = i@e 2 j = j@e 2 k = k@e 2 1 implica 0 i j k a implica implica I E 1 : mismos(a, pre(a)) 0 i j < k a a j = 0 swap(a,i,j); E 2 : a j = a 1 a i = a 1 ( t [0.. a ), t i, j)a t = a 1 i = i@e 1 j = j@e 1 k = k@e 1 implica a i = 0 (i < j a j = 1) implica a[0..i] = 0 a(i..j) = 1 a[k.. a ) = Caso 3: a j = 0 Caso 3: a j = E 2 : mismos(a, pre(a)) 0 i j < k a a[0..i] = 0 a(i..j) = 1 a[k.. a ) = 2 (i < j a j = 1) ++i; E 3 : a = a@e 2 i = i@e j = j@e 2 k = k@e 2 implica 0 i 1 j < k a implica E 3 : mismos(a, pre(a)) 0 i 1 j < k a (i < j a j = 1) E 3 : a = a@e 2 i = i@e 2 j = j@e k = k@e 2 implica 0 i j k a implica implica I 15 16

5 Tenemos el cuerpo del ciclo, que (1) preserva el invariante. j = 0; k = a.length; while( j!= k ) { I B :... if( a[j] == 0 ) { swap(a,i,j); ++i; else if( a[j] == 1 ) else if( a[j] == 2 ) { swap(a,j,k-1); --k; Por construcción, (2) la inicialización establece el invariante: P c : i = 0 j = 0 k = a a = pre(a) I : mismos(a, pre(a)) 0 i j k a Además, (3) al salir del ciclo vale la postcondición: I B: mismos(a, pre(a)) 0 i j = k a mismos(a, pre(a)) ( i, j [0.. a ), i j) a[0..i) = 0 a[i..j) = 1 a[j.. a ) = En cada una de las tres ramas, (4) el variante decrece: E 1 : mismos(a, pre(a)) 0 i j < k a a j = 1... E 2 : k = k@e 1 j = j@e implica k j < (k j)@e 1 E 1 : mismos(a, pre(a)) 0 i j < k a a j = 2... swap(a,j,k-1); --k; E 2 : k = k@e 1 1 j = j@e 1 implica k j < (k j)@e 1 E 1 : mismos(a, pre(a)) 0 i j < k a a j = 0... swap(a,i,j); ++i; E 2 : k = k@e 1 j = j@e implica k j < (k j)@e 1 Finalmente, (5) cuando el variante pasa la cota, el ciclo termina, puesto que k j 0 B. Por lo tanto, el algoritmo es correcto respecto de su especificación

6 Cuál es la complejidad del algoritmo? 1. Antes de comenzar las iteraciones, v = a. 2. En cada iteración, el variante decrece estrictamente. 3. Cuando v 0, el ciclo termina. Entonces, el algoritmo realiza a lo sumo a iteraciones (más aún, realiza exactamente a iteraciones, dado que en cada paso el variante decrece en exactamente una unidad). El algoritmo tiene una complejidad de O(n). 21