ELO320 Estructuras de Datos y Algoritmos. Complejidad. Tomás Arredondo Vidal

Transcripción

1 ELO320 Estructuras de Datos y Algoritmos Complejidad Tomás Arredondo Vidal Este material está basado en: Robert Sedgewick, "Algorithms in C", (third edition), Addison-Wesley, 2001 Thomas Cormen et al, Algorithms, (eighth edition), MIT Press, material del curso ELO320 del Prof. Leopoldo Silva material en el sitio 7: Complejidad 1

2 7-Complejidad 7.1 Tiempo de ejecución: T(n) 7.2 Complejidad: O(n) 7.3 Complejidad: Θ(n) 7.4 Algoritmos 7: Complejidad 2

3 Tiempo de ejecución: T(n) Se desea tener una medida de la duración del tiempo de ejecución de un algoritmo en función del tamaño de la entrada n. A través de llamados al sistema operativo se puede conocer el valor del reloj del procesador. Invocando el reloj (e.g. usando clock( ) en Unix), antes y después de realizar el algoritmo se tendrá una medida de la duración del tiempo de ejecución: T(n). Esta medida es muy dependiente del hardware (memoria, reloj, procesador) y software (sistema operativo). 7: Complejidad 3

4 Tiempo de ejecución: T(n) (cont) Por la razón anterior como una medida del tiempo de ejecución, se considera contar las instrucciones del lenguaje de alto nivel que son necesarias realizar. El tamaño de la entrada (n) debe ser precisado con más detalle. En forma tradicional n se considera como el número de elementos o componentes básicos que son sometidos al proceso o algoritmo siendo medido. También se suele denominar a T(n) como una complejidad temporal. 7: Complejidad 4

5 Tiempo de ejecución: T(n) (cont) La función T(n) mide el tiempo que el algoritmo requiere para procesar los n elementos de entrada. El tiempo de ejecución de un algoritmo es la suma de los tiempos de cada línea ejecutada (i.e. statement) Una línea de código i que toma tiempo C i (e.g. pasos o ciclos del reloj) para ejecutar y se ejecuta n veces va a contribuir nc i al tiempo de ejecución del programa. Se debe sumar el tiempo de todas las líneas del programa para obtener T(n). Afecta al tiempo de ejecución el orden en que se presentan los elementos de entrada: un caso típico o promedio (e.g. random), el mejor caso posible, el peor caso posible (típicamente el caso mas importante). 7: Complejidad 5

6 Tipos de funciones de T(n) Las funciones T(n) pueden ser de varios tipos: Funciones constantes: T (n) = 5, T (n) = 10 Funciones logarítmicas: T (n) = log(n), T (n) = nlog(n) Funciones polinomiales: T (n) = 2n 2, T (n) = 8 n 2 + 5n Funciones exponenciales: T (n) = 2 n, T (n) = 2 5n Mezclas de las anteriores, Cualquier función de n en un caso general. 7: Complejidad 6

7 Ejemplo: Cálculo de T(n) (cont) Se calculan los tiempos asociadas a cada línea considerando como operaciones elementales a: comparaciones, asignaciones, sumas, restas, acceso a elementos. Cada operación elemental tiene asociado una unidad de tiempo (e.g. una constante o simplemente el valor 1). También se podría considerar esta unidad como cualquier constante (i.e. O(1)). 7: Complejidad 7

8 Ejemplo: Cálculo de T(n), (1era approx.) Algoritmo de ordenamiento (peor caso): (t i - 1) void Alg1(int a[], int n) { int i, j, temp; line cost times for (i=0; i<n-1; i++) //1 : C 1 t 1 = Σ i for (j=n-1; j>=i+1; j--) //2 : C 2 t 2 = Σ i (Σ j (...)) } if(a[j-1] > a[j]) { //3 : C 3 t 2-1 } temp=a[j-1]; //4 : C 4 t 2-1 a[j-1]=a[j]; //5 : C 5 t 2-1 a[j]=temp; //6 : C 6 t 2-1 7: Complejidad 8

9 Ejemplo: Cálculo de T(n) (2nda approx.) Sumando las operaciones ejecutadas por cada línea (peor caso) en su inicialización, iteración y salida: C 1 = ops 1 = en cada iteración + 2 C 2 = ops 2 = en cada iteración + 2 C 3 = ops 3 = 4 C 4 = ops 4 = 3 C 5 = ops 5 = 4 C 6 = ops 6 = 2 Las operaciones internas se realizan: (n-1) - (i+1) + 1 = (n-i-1) veces Considerando el for interno, T(n) tiene un costo: n 1 ( ) = 2 + T n ( ) + 2 = j= i ( n i 1) Considerando el for externo, T(n) tiene un costo: T ( n) = 1+ n 2 i= 0 (4 + (4 + 17( n i 1))) + 2 7: Complejidad 9

10 Ejemplo: Cálculo de T(n) (2nda approx.) El for externo tiene un costo: T ( n) = 1+ n 2 i= 0 (4 + (4 + 17( n i 1))) + 2 Arreglando y considerando los términos que no dependen de i se suman (n-1) veces: T ( n) = 3+ = 3 + n 2 i= 0 n 2 i= 0 (8 + 17( n i 1)) (8 + 17n 17 17i)) = 3 + (8 + 17n 17)( n 1) 17 n 2 i= 0 ( n 2)( n 1) = 3 + (8 + 17n 17)( n 1) = (17n n + 7) / 2 i 7: Complejidad 10

11 7-Complejidad 7.1 Tiempo de ejecución: T(n) 7.2 Complejidad: O(n) 7.3 Complejidad: Θ(n) 7.4 Algoritmos 7: Complejidad 11

12 O(n): Acotamiento de funciones El acotamiento de funciones permite clasificar las funciones por su orden de magnitud. Interesa encontrar una cota superior del crecimiento de la función T(n) a medida que n. Consideremos la siguiente definición preliminar de la función O mayúscula, con la intención de clasificar funciones de n. Ejemplo: se dice que T(n) es O(n i ), si existen constantes c 0 y n 0 tales que T(n) <= c 0 n i para todos los n >= n 0 7: Complejidad 12

13 Ejemplo: O(n) Sea T(n) = (n + 1) 2. Para el menor i posible... Hay que encontrar c 0 y n 0 tales que: (n + 1) 2 <= c 0 n i. 7: Complejidad 13

14 Ejemplo: O(n) (cont) Dado que T(n) = (n +1) 2. T (n) es O(n i ) si para el menor i posible se encuentran c 0 y n 0 tales que: T(n) <= c 0 n i (n+1) 2 <= c 0 n i. Si suponemos que i = 3: la desigualdad anterior se cumple para c = 4 y n >= 1 la desigualdad anterior se cumple para c = 2 y n >= 1,4376 Si suponemos que i = 2: la desigualdad anterior se cumple para c = 4 y n >= 1 Si suponemos que i = 1 la desigualdad no se cumple. Lo cual prueba que: T(n) = O(n 2 ). 7: Complejidad 14

15 O(n): Complejidad (O-notation) Definición de O(n): Se dice que T(n) es O( f(n) ) solo si existen c y n 0 tales que: T(n) <= c f(n) con n >= n 0 Sin embargo es posible acotar mejor el orden o magnitud de una función. Esto considerando el primer ejemplo, en el que se podía decir que T(n) era O(n 3 ) y también que era O(n 2 ). Θ(n) acota T(n) superior e inferiormente 7: Complejidad 15

16 Actividad: Probar que: T (n) = 3n 3 + 2n 2 es O(n 3 ) 7: Complejidad 16

17 O(n): Costo Unitario Aplicando la definición puede comprobarse que las funciones T(n) constantes tienen complejidad O(1). Ejemplo: Sea T(n) = 5. Se puede escribir: 5 <= c 1 con n >= n 0 Es simple encontrar: c = 6 y cualquier n 0 Es decir f(n) = 1. Con lo cual, se puede afirmar que : T(n) = 5 es O(1) para todo n. Una de las mayores simplificaciones para cálculos de complejidad es considerar que las acciones primitivas del lenguaje son de costo unitario. 7: Complejidad 17

18 O(n): Teorema de acciones secuénciales Teorema de acciones secuenciales: Se realiza la acción A, como la secuencia dos acciones A 1 y A 2 de complejidades temporales T 1 (n) y T 2 (n) respectivamente. Si T 1 (n) es O(f(n)) y T 2 (n) es O(g(n)) entonces A es de complejidad O( max( f(n), g(n) ). 7: Complejidad 18

19 O(n): Teorema de productos Teorema de productos. Si T 1 (n) es O(f(n)) y T 2 (n) es O(g(n)) entonces: T 1 (n)t 2 (n) es O( f(n) g(n) ). Ejemplos: O( 3 n 2 ) =? O( 3 n 2 ) = O (n 2 ) ya que 3 es O(1), y n 2 es O(n 2 ). Si c es una constante y n el tamaño de la entrada: O(c) = c*o(1) = O(1) O(cn) = c*o(n) = O(n) La regla del producto también puede aplicarse en: n*o( n ) = O (n 2 ) 7: Complejidad 19

20 O(n): Teorema de alternativas Teorema de alternativa if (...) then A1 else A2 A1(n) es O(f(n)) y A2(n) es O(g(n)) Se toma la complejidad de la acción de mayor orden, entonces esta condición es O( max(f(n), g(n) )). 7: Complejidad 20

21 O(n): Teorema de iteraciones Teorema de iteración for ( i = 0; i < n; i++) { } a; Por regla de sumas se tiene n veces la complejidad temporal de la acción a. Si la acción del bloque a es O(1) entonces el for es de complejidad n *O(1) = O(n) 7: Complejidad 21

22 7-Complejidad 7.1 Tiempo de ejecución: T(n) 7.2 Complejidad: O(n) 7.3 Complejidad: Θ(n) 7.4 Algoritmos 7: Complejidad 22

23 Θ(n): Acotamiento superior e inferior Una mejor definición para acotar funciones, es la función Big Theta Θ(n) que define simultáneamente cotas superior e inferiores para T(n). Es la definición preferencial de complejidad. Definición de Θ(n): Se dice que T(n) es Θ( f(n) ), si existen c 1, c 2 y n 0 tales que: c 1 f(n) <= T(n) <= c 2 f(n) con n >= n 0 7: Complejidad 23

24 Ejemplo Θ(n): Para el ejemplo anterior, c 1 = 3, y c 2 = 5, con n 0 =1. 7: Complejidad 24

25 Actividad Θ(n): Se tienen tres for anidados: for (i = 1; i <= n-1; i++) for( j = i+1; j <= n; j++) for (k = 1; k <= j; k++) { a[i]=a[j+2] ; } Calcular Θ(n). 7: Complejidad 25

26 7-Complejidad 7.1 Tiempo de ejecución: T(n) 7.2 Complejidad: O(n) 7.3 Complejidad: Θ(n) 7.4 Algoritmos 7: Complejidad 26

27 Evaluando la complejidad en función del tiempo: Dado que T(n) refleja el número de instrucciones de costo unitario que deben realizarse para n entradas Si T(1) es equivalente a 1 [μseg], se puede construir la siguiente tabla de tiempos de ejecución: El teorema de sumas nos da que: O(3n 2 + 7n) = O(n 2 ). La tabla muestra que las complejidades de los dos algoritmos cuadráticos son comparables en el orden de magnitud. 7: Complejidad 27

28 Relaciones de recurrencia: En varios casos de mucho interés se conoce la complejidad temporal de un algoritmo mediante una relación de recurrencia. Por ejemplo: T(n) = T(n/2) + c con T(1) = c. Es decir el algoritmo aplicado a una entrada de tamaño n, puede descomponerse en un problema de la mitad del tamaño. El costo de la descomposición es una constante de valor c. Para resolver una relación de recurrencia es preciso conocer el costo para una entrada dada; en este caso para entrada unitaria T(1) el costo es la constante c. 7: Complejidad 28

29 Relaciones de recurrencia: T(n)=O(log 2 n) Esto ocurre en programas que en cada pasada descartan la mitad de los datos de entrada Si a partir del caso conocido se van evaluando casos más complejos, pueden obtenerse una expresión general: T(n) Tiempo T(1) = c = c = 0 + c T(2) = T(1) + c = 2c = c + c T(4) = T(2) + c = 3c = 2c + c T(8) = T(4) + c = 4c = 3c + c T(16) =T(8) + c = 5c = 4c + c T(2 i ) = T(2 i-1 ) + c = (i+1)c= ic + c = c(i+1) 7: Complejidad 29

30 Relaciones de recurrencia: T(n)=O(log 2 n) Se han evaluado en números que son potencias de dos, para obtener con una expresión para el término general: Con 2 i = n, sacando logaritmo de dos en ambos lados: log 2 (2 i ) = log 2 (n), pero log 2 (2 i ) = i log 2 (2) = i. Resultando: i = log 2 (n). Reemplazando en la expresion general T(n) = c(i+1): T(n) = c(log 2 (n) + 1) 7: Complejidad 30

31 Relaciones de recurrencia: T(n)=O(log 2 n) Las gráficas muestran que para T(n) existen c1 y c2 que la acotan por encima y por debajo, para n > 2,2. Finalmente, se tiene que la solución de la ecuación de recurrencia es: T(n) = O( log 2 (n) ) 7: Complejidad 31

32 Relaciones de recurrencia: T(n)=O(log 2 n) Las gráficas comparan el costo lineal versus el logarítmico. 7: Complejidad 32

33 Búsqueda secuencial La búsqueda secuencial compara una clave con cada una de las n componentes. La primera vez que encuentre un elemento del arreglo igual al valor buscado se detiene el proceso. No encuentra claves repetidas y no se requiere que el arreglo esté ordenado. Si lo recorre en su totalidad, cuidando de no exceder los rangos del arreglo, y no lo encuentra debe indicarlo con algún valor específico de retorno. Se retornar el índice de la componente que cumple el criterio de búsqueda, un retorno con valor -1 (ya que no es un índice válido), indicará que el valor no fue hallado. 7: Complejidad 33

34 Búsqueda secuencial (cont) Indice BusquedaSecuencial(Tipo A[], Indice Inf, Indice Sup, Tipo Clave) { } Indice i; for (i = Inf; i <= Sup; i++) if (A[i] == Clave) return(i); return (-1) ; // no se encontró La iniciación del for es O(1). La condición del if es O(1), también el retorno es O(1). El test de la condición del for es O(1), también el incremento de i es O(1). El bloque se repite (Sup-Inf+1) veces en peor caso. T(n) = O(1) + (Sup-Inf + 1)*( O(1) + (O(1) + O(1)) + O(1) ) + O(1) Simplificando: T(n) = (Sup-Inf+1) O(1) + O(1) = O(Sup-Inf+1) La entrada n, es el número de componentes en las que se busca. Si n = Sup Inf+1, se tiene finalmente: T(n) = O(n). 7: Complejidad 34

35 Búsqueda binaria Se requiere tener un arreglo ordenado en forma ascendente. El algoritmo está basado en ubicar, mediante la variable auxiliar M, la mitad del arreglo aproximadamente: Entonces o se lo encuentra justo en el medio; el costo de encontrar la mitad es de costo constante. o en la mitad con índices menores que M si el valor buscado es menor que el de la componente ubicada en la mitad; o en la mitad con índices mayores que M si el valor buscado es mayor. El ajustar los índices también es de costo constante, corresponde a los dos if then else anidados. Si se tienen n componentes, la complejidad puede describir según: T(n) = T(n/2) + c La solución de esta ecuación de recurrencia es: T(n) = O(log(n)). 7: Complejidad 35

36 Búsqueda binaria (cont) int BusquedaBinaria(Tipo A[], Indice Inf, Indice Sup, Tipo Clave) { Indice M; while (verdadero) { M = (Inf + Sup)/2; if (Clave < A[M]) Sup = M - 1; else if (Clave > A[M]) Inf = M + 1; else return M; if (Inf > Sup) return (noencontrado) ; } } 7: Complejidad 36

37 Algoritmos de multiplicación Un algoritmo primitivo para efectuar multiplicaciones es mediante la suma repetitiva de uno de los operandos. Por ejemplo el producto de dos números de 4 bits: 0101* Este algoritmo requiere n sumas si los operandos son de n bits Lo cual implica un costo O(n 2 ) para la multiplicación, considerando que cada suma es de costo O(n). Razón por la cual se suelen diseñar unidades de multiplicación, en hardware, con mejores algoritmos. Cual es la complejidad considerando la suma como O(n)? 7: Complejidad 37

38 Algoritmos de multiplicación (cont) En un ambiente de microcontroladores o microprocesadores que no tengan implementadas la operación multiplicación o división, pero que si tengan: sumas, restas y desplazamientos a la izquierda y derecha en un bit, se pueden considerar esas instrucciones de costo O(1). Consideremos, en este último contexto, dos algoritmos para multiplicar: 7: Complejidad 38

39 Algoritmos de multiplicación (cont) /* retorna m*n */ unsigned int multiplique1(unsigned int m, unsigned int n) { } unsigned int r=0; while ( n>0 ) { } r+=m; n--; return(r); Cual es la complejidad? El bloque se repite n veces, y está constituido por un test de condición, una suma y un incremento. Todas operaciones que pueden traducirse a instrucciones de máquina, y se consideran de costo O(1). Entonces esta multiplicación es de costo O(n) o lineal. 7: Complejidad 39

40 Algoritmos de multiplicación (cont) /* retorna m*n */ unsigned int multiplique2(unsigned int m, { unsigned int r=0; while ( n>0 ) { } if(n&1) r+=m; m*=2; n/=2; return(r); } unsigned int n) Cual es la complejidad? En cada ciclo del while se divide por dos el valor de n. Multiplicación por dos (o left shift << 1) La división por dos equivale a un right shift (>> 1) El test del bit menos significativo se realiza con una operación and; acumular el producto parcial en la local r, se efectúa con una suma. Todas estas operaciones, en este ambiente se consideran de costo constante: con T(1) = O(1). El algoritmo puede describirse : T(n) = T(n/2) + O(1) = O(log 2 n) 7: Complejidad 40

41 Algoritmos de división Consideremos un algoritmo primitivo de división, basado en restas sucesivas. /* Retorna cuociente q y resto r. n = q*d + r. */ unsigned int divide1( unsigned int n, unsigned int d, unsigned int *r) { unsigned int q=0; while (n >= d) { } n -= d; q++; *r = n; //escribe el resto return(q); } Cual es la complejidad? En su peor caso, con denominador unitario, y n el máximo representable, se tiene costo: O(n). Entonces esta multiplicación es de costo O(n) o lineal. 7: Complejidad 41

42 Algoritmos de división (cont) // n/d -> q, r. Retorna cuociente q // y resto r. Con n = q*d + r. unsigned int divide2( unsigned int n, unsigned int d, unsigned int *r) { unsigned int dd=d, q=0; *r = n; while (dd <= n) dd*=2; while (dd > d) { dd/=2; q= q*2; if (dd <= *r) { *r-=dd; q++; } } return(q); } Cual es la complejidad? El primer while duplica el den. hasta que sea mayor que el num. Para 8 bits, el mayor numerador será: bin o 255dec. Si d es 1, el while genera lo siguiente para dd: 2, 4, 8, 16, 32, , 256. Y se realiza 8 veces. Lo cual también se puede calcular mediante log 2 (256) = log 2 (2 8 ) = 8. En el peor caso con d=1 y con el máx valor para n, se tienen log 2 n repeticiones. El segundo while divide por 2 el tamaño de dd que despues del primer loop es = n, su costo es: O(log 2 n) O(log 2 n) + O(log 2 n) = O(log 2 n) 7: Complejidad 42

43 Relaciones de recurrencia: T(n)=O(nlog 2 n) Esto ocurre en programas que en cada pasada descartan la mitad de los datos de entrada pero con un costo proporcional a n en cada iteración. Aparece en métodos basados en particiones (dividir para conquistar). Si a partir del caso conocido se van evaluando casos más complejos, pueden obtenerse: T(n) T(1) = c = c Tiempo T(2) = 2*T(1) + 2*c = 4c = 2c * 2 T(4) = 2*T(2) + 4*c = 12c = 4c * 3 T(8) = 2*T(4) + 8*c = 32c = 8c * 4 T(16) = 2*T(8) + 16*c = 80c = 16c * 5 T(2 i ) = 2*T(2 i-1 ) + 2 i c = (i+1)c= ic + c = 2 i c*(i+1) 7: Complejidad 43

44 Relaciones de recurrencia: T(n)=O(nlog 2 n) Se han evaluado en números que son potencias de dos, para obtener con una expresión para el término general: Con 2 i = n, sacando logaritmo de dos en ambos lados: log 2 (2 i ) = log 2 (n), pero log 2 (2 i ) = i log 2 (2) = i. Resultando: i = log 2 (n). Reemplazando en la expresión T(n) = 2 i c*(i+1): T(n) = nc * (log 2 (n) + 1) 7: Complejidad 44

45 Relaciones de recurrencia: T(n)=O(nlog 2 n) Las gráficas muestran que para T(n) existen c1 y c2 que la acotan por encima y por debajo, para n >= 2. Finalmente, se tiene que la solución de la ecuación de recurrencia es: T(n) = O( nlog 2 (n) ) 7: Complejidad 45

46 Comparación entre algunas complejidades 7: Complejidad 46