Ordenamiento de un arreglo. Algoritmos y Estructuras de Datos I. Demostración. Cota inferior de complejidad tiempo para sorting

Transcripción

1 Ordenamiento de un arreglo Algoritmos y Estructuras de Datos I Segundo cuatrimestre de 2014 Departamento de Computación - FCEyN - UBA Algoritmos - clase 12 Algoritmos de ordenamiento, segunda parte Tenemos un arreglo de un tipo T con una relacïı 1 2n de orden ( ) y queremos modificar el arreglo para que sus elementos queden en orden creciente. problema sort<t> (a : [T], n : Int) { requiere n == a > 1; 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 Cota inferior de complejidad tiempo para sorting Demostración Supongamos que ordenamos esta secuencia: 3, 2, 4, 5, 1. El método comparará los números, y según sean los resultados de las comparaciones permutará los elementos. El efecto neto será: Consideremos algoritmos de ordemiento basados, exclusivamente, en operaciones de comparar elementos y permutarlos. Teorema: Sea cualquier método de ordenamiento (inventado o por inventarse). Ordenar n elementos toma al menos log 2 (n!) pasos. El método no puede ejecutar exactamente de la misma manera si la secuencia es otra, por ejemplo: 2, 3, 4, 5, 1 Por qué? Si lo hiciera, el resultado neto sería 3 Concluímos que la ejecución debe ser una sucesión de pasos distinta para cada permutación posible de la secuencia de entrada. 4

2 Visualicemos todas las ejecuciones como un árbol de ejecuciones. Cada nodo es, o bien una asignación, o bien una comparación. El árbol se ramifica en cada comparación. Cada camino desde la raíz hasta una hoja es una ejecución del programa. La altura del árbol da el peor caso de cantidad de instrucciones ejecutadas por el programa. Si éste es el árbol de ejecuciones de un programa de ordenamiento, que ordena n elementos, para cada una de las n! permutaciones de la secuencia de entrada, la ejecución debe alcanzar una hoja diferente. El árbol debe tener al menos n! hojas. 5 Debe tener al menos n! hojas. Sabemos que un árbol binario con L hojas tiene altura al menos log 2 L. Por lo tanto nuestro árbol tiene altura al menos log 2 n!. Concluímos que el ordenamiento, en el peor caso, requiere al menos log 2 n! pasos. 6 ï 1 2 Ordenamiento mï 1 2 s rï 1 2 pido? En la materia Algoritmos y Estructuras de Datos II verï 1 2 n algoritmos que tienen complejidad O(n log n). Y estudiarï 1 2n a fondo las ventajas y desventajas de cada uno. Para poder hacer un ordenamiento más rápido necesitamos... sort count es un algoritmo eficiente para ordenar un arreglo de enteros de dimensión n, cuyos valores están entre 0 y n 1. saber más acerca de la secuencia de entrada, de forma tal de poder ahorrarnos comparaciones entre elementos. 7 8

3 problema sort count(a : [Int], n : Int) { requiere n == a 1; requiere ( i [0.. a )) 0 a i < a ; asegura mismos(a, pre(a)) ordenado(a); aux ordenado(c) = ( i [0.. c 1))c[i] c[i + 1] aux mismos(b, c) = b == c todos([cuenta(x, b) == cuenta(x, c) x b]) Sea a el arreglo de entrada. El algoritmo sort count usa una estructura auxiliar b, de la misma dimensïı 1 2n que a, donde contaremos la cantidad de ocurrencias de cada elemento. En b[i] indicaremos la cantidad de ocurrencias de i en a. Esto es posible porque los elementos de a son enteros mayores o iguales que 0 y menores que la dimensïı 1 2n de a. Luego, ordenaremos a escribiendo de izquierda a derecha cada uno de sus elementos con su correspondiente cantidad de ocurrencias registrada en b problema cuenta ocurrencias(a : [Int], n : Int, b : [Int]){ requiere a == n; requiere b == n; requiere todos([0 a[i] < n i [0..n)]); modifica b; asegura b == [cuenta(i, a) i [0..n)]; aux cuenta(x, c) = [β(x == c[j]) j [0.. c )]; problema reconstruye(a : [Int], n : Int, b : [Int]){ requiere a == n; requiere b == n; asegura ordenado(a); asegura ( i [0..n))cuenta(i, a) == b[i]; aux cuenta(x, c) = [β(x == c[j]) j [0.. c )]; problema init(a : [Int], val : Int, n : Int){ requiere n == a n > 0; asegura todos([a[j] == val, j [0..n)]); problema asigna(a : [Int], desde : Int, cant : Int, val : Int){ requiere desde 0 desde + cant a ; asegura todos([a[j] == val, j [desde..desde + cant)]); 11 12

4 Cuenta ocurrencias void cuenta ocurrencias(int a[], int b[], int n){ init(b,0,n); int i=0; // Pc:i == 0 ( j [0.. b ))b[j] == 0; while (i< n) { // invariante I: 0 i a // ( j [0..i))b[a[j]] == cuenta(a[j], a[0..i)); // variante v: n i, cota 0 b[a[i]]=b[a[i]]+1; i++; // Qc: ( i [0.. a ))cuenta(i, a) == b[i]; 13 Reconstruye el arreglo ordenado a partir de las ocurrencias void reconstruye(int a[], int b[], int n){ int i=0; int j=0; // Pc: i == 0 j == 0; while (i<n) { // invariante I: (0 i n) (0 j n) ordenado(a[0.. b[0..i)) // ( k [0..i))cuenta(k, a[0.. b[0..i))) == b[k]; // variante v:n i asigna(a,j,b[i], i); j=j+b[i]; i++; // Qc: ordenado(a) ( k [0.. a ))cuenta(k, a) == b[k]; void asigna(int a[], int desde, int cant, int val){ int k = desde; // Pc: k == desde; while (k < desde+cant){ // invariante I: (desde k desde + cant) todos([a[m] == val m [desde..k)]) // variante v: desde + cant k, cota 0; a[k] = val; k++; // Qc:todos([a[m] == val m [desde..desde + cant)]); 14 sort count tiene complejidad lineal void sort count(int a[], int n) { int b[n]; // estado e 0; // vale P: a == pre(a) n == a 1 ( i [0.. a )) 0 a i < a ; cuenta ocurrencias(a,b,n); // estado e 1; // vale a== a@e0; // vale ( k [0.. a )) cuenta(k, a) == b[k]; reconstruye(a,b,n); // estado e 2; // vale ordenado(a) ( k [0.. a )) cuenta(k, a) == b[k]; // implica ordenado(a) ( k [0.. a )) cuenta(k, a) == cuenta(k, a@e0); porque b[k] == cuenta(k, a@e0) // implica Q: ordenado(a) mismos(a, pre(a)); ( i [0.. a )) 0 (a@e0) i < a ]); Los elementos de a son mayores o iguales que 0 y menores que la longitud de a. El algoritmo usa un arreglo auxiliar b de la misma longitud que a. Para contar ocurrencias de los elementos de a leemos a una sola vez, de izquierda a derecha, mientras acumulamos en b. Para reconstruir a necesitamos leer b una sola vez, de izquierda a derecha, mientras escribimos a tambïı 1 2n de izquierda a derecha. El algoritmo tiene complejidad O( a )

5 Problema de la bandera holandesa Algoritmo de la bandera holandesa Supongamos que tenemos la siguiente hipótesis adicional: problema dfp(a : [Int], n : Int) { requiere n == a 1; requiere ( i [0.. a )) 0 a i 2; asegura mismos(a, pre(a)) ordenado(a); Queremos un algoritmo de complejidad lineal, O(n) para n = a, pero que no use una estructura de datos adicional para contar ocurrencias. Queremos modificar el arreglo haciendo swaps. La postcondición se puede escribir de la siguiente forma equivalente: asegura mismos(a, pre(a)) ( i, j [0.. a ), i j) a[0..i) == 0 a[i..j) == 1 a[j.. a ) == 2 Abusando notación, definimos: a[d, h) == x ( l [d, h)) a l == x En forma gráfica: i j Algoritmo de la bandera holandesa Programa de la bandera holandesa El invariante se obtiene haciendo variar las variables i, j, k: I: mismos(a, pre(a)) 0 i j k a a[0..i) = 0 a[i..j) == 1 a[k.. a ) == 2 En forma gráfica: 0 1? 2 El invariante es equivalente a la postcondición cuando j==k. Con ésto deducimos la guarda del ciclo. Para inicializar trivialmente un estado que cumple el invariante hacemos: i = 0; j = 0; k = n; asumiendo a == n. void dfp(int a[], int n) { int i = 0; int j = 0; int k = n; while( j!= k ) { if( a[j] == 1 ) else if( a[j] == 2 ) { swap(a,j,k-1); k--; else if( a[j] == 0 ) { swap(a,i,j); i++; 19 20

6 Programa de la bandera holandesa Caso 1: a j == 1 void dfp(int a[], int n) { int i = 0; int j = 0; int k = n; while( j!= k ) { I B :... a[0..i) == 0 a[i..j) == 1 a[k..n) == 2; if( a[j] == 1 ) I... j k a j == 1; else if( a[j] == 2 ) I... j k a j == 2; else if( a[j] == 0 ) I... j k a j == 0; 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 mismos(a, pre(a)) implica 0 i j k a implica a j 1 == 1 a[i..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 == 2 Caso 3: a j == E 1 : mismos(a, pre(a)) 0 i j < k a a j == 2 swap(a,j,k-1); E 1 : mismos(a, pre(a)) 0 i j < k a a j == 0 swap(a,i,j); E 2 : a j == (a@e 1 ) i a i == (a@e 1 ) j ( t [0.. a ), t i, t j)a t == a 1 i == i@e 1 j == j@e 1 k == k@e 1 implica mismos(a, pre(a)) 0 i j < k a implica a i == 0 (i < j a j == 1) implica a[0..i] == 0 a(i..j) == 1 a[k.. a ) == 2 i++; E 3 : a == a@e 2 i == i@e j == j@e 2 k = k@e 2 implica mismos(a, pre(a)) implica 0 i 1 j < k a implica (i 1 < j a j == 1) implica E 2 : a j == (a@e 1 ) k 1 a k 1 == (a@e 1 ) j ( t [0.. a ), t j, t k 1) a t == (a@e 1 ) t i == i@e 1 j == j@e 1 k == k@e 1 implica mismos(a, pre(a)) 0 i j < k a implica a k 1 == 2 implica 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 mismos(a, pre(a)) implica 0 i j k a implica implica I 23 24

7 Caso 3: a j == 0 Correctitud del programa la bandera holandesa E 3 : mismos(a, pre(a)) 0 i 1 j < k a (i 1 < j a j == 1) E 4 : a == a@e 2 i == i@e 2 j == j@e k == k@e 2 implica mismos(a, pre(a)) implica 0 i j k a implica (i < j a j 1 == 1) implica implica I Tenemos el cuerpo del ciclo, que (1) preserva el invariante. i = 0; j = 0; k = n; while( j!= k ) { I B :... if( a[j] == 1 ) else if( a[j] == 2 ) { swap(a,j,k-1); k--; else if( a[j] == 0 ) { swap(a,i,j); i++; Correctitud del programa la bandera holandesa Correctitud del programa la bandera holandesa En cada una de las tres ramas, (4) el variante decrece: k j; cota 0 Por construcción, (2) la inicialización establece el invariante: P c : i == 0 j == 0 k == a a == pre(a) implica I : mismos(a, pre(a)) 0 i j k a Además, (3) al salir del ciclo vale Qc: I B: mismos(a, pre(a)) 0 i j == k a implica Qc: mismos(a, pre(a)) ( i, j [0.. a ), i j) a[0..i) == 0 a[i..j) == 1 a[j.. a ) == 2; 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

8 Correctitud del programa la bandera holandesa Complejidad del algoritmo de la bandera holandesa Finalmente, (5) cuando el variante pasa la cota, el ciclo termina, ya que k j 0 B. Por lo tanto, el ciclo es correcto respecto de su especificación. Luego, como Qc implica las poscondición del problema (son iguales en este caso), el algoritmo es correcto respecto de su especificación. 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 (realiza exactamente a iteraciones, dado que en cada paso el variante decrece en exactamente una unidad). El algoritmo tiene complejidad O(n)