Universidad DaVinci Dr. Vicente Cubells (vcubells@udavinci.edu.mx)
Temario Complejidad Temporal Espacial Notación asintótica
• Predecir la cantidad de recursos (almacenamiento, tiempo de cómputo o número de operaciones) que el algoritmo requerirá para cualquier entrada • Velocidad de ejecución de un algoritmo • Determinar bajo qué circunstancias un algoritmo es mejor que otro
Análisis
Tiempo de CPU Uso de memoria Ancho de banda
Eficiencia de un algoritmo Recursos: espacio y tiempo A priori (teórico) obtener una expresión que indique el comportamiento del algoritmo en función de los parámetros A posteriori (empírico) se recogen estadísticas de tiempo y espacio consumidos por el algoritmo mientras se ejecuta
una máquina concreta, un lenguaje concreto, un compilador concreto y datos concretos
Complejidad Se analiza un algoritmo para poder conocer su
complejidad. Complejidad temporal:
Se denota como T(n), y es el tiempo que se requiere para
procesar una entrada de tamaño n. Sea T(n) la complejidad temporal de algún programa, se asume lo siguiente:
El argumento n es un entero no negativo. T(n) es no negativo para todo n.
Complejidad espacial: Se denota como S(n) e indica la cantidad de espacio que requiere un programa para procesar una entrada de tamaño n.
Complejidad temporal Se calcula de la siguiente manera:
T (n) =
∑ (num * c ) i
i
∀i ∈ Instrucciones
Donde numi = es el número de veces que se ejecuta la instrucción i. ci = es el costo o tiempo de ejecución para la instrucción i.
Ejemplo 1 de T(n) void imprime_arreglo(int arreglo[], int n) { int i = 0; while (i < n) { printf(“El elemento %d es %d \n”, i, arreglo[i]); ++i; } }
T
n
c1
1
c2
n+1
c3
n
c4
n
Ejemplo 2 de T(n) #define n 3 int vector [n]; int Buscar(int &a[n], int c) { int j = 1; while (a[j]< c) and (j<n) { j=j+1; } if (a[j]==c ) { return j; } else { return 0 ; } }
OE 1 4 2
m 1 2
p
1/2
1 1 ( n −1) / 2 4n (4 + 2)) + 2 2(n-‐1) (
∑ i =1
2
2
2
2
1
1
1
1
ó
ó
ó
ó
1
1
1
1
T(s)=
6
6n + 2
3n+3
Principio de Invarianza Dado un algoritmo y dos implementaciones suyas I1 e
I2, que tardan T1(n) y T2(n) segundos respectivamente, existe una constante real c > 0 y un número natural n0 tales que para todo n ≥ n0 se verifica que T1(n) ≤ cT2(n)
Ejemplo: Sean dos algoritmos A1 y A2 con complejidades n3 y n respectivamente si cada paso de A1 tarda 1/100 para cada paso de A2 …
Notación O grande f(n) es O(g(n)) si f crece a lo sumo tan rápido como g f(n) es O(g(n)) si existe un entero n0 y una constante c
> 0, tal que, para todos los enteros n >= n0 se cumple que : f(n) <= cg(n)
f ( n) f ∈ O( g ) si lim =c<∞ n →∞ g ( n) Ejemplo: 3n3 + 5n2 – 9 = O(n3).
Notación Ω grande f(n) es Ω(g(n)) si f crece al menos tan rápido como g f(n) es Ω(g(n)) si existe un entero n0 y una constante c
> 0, tal que, para todos los enteros n >= n0 se cumple que : f(n) >= cg(n)
f ∈ Ω( g ) si lim n →∞
g ( n) =c<∞ f ( n)
Notación Θ grande f(n) es Θ(g(n)) si f es lo mismo que g (crecen igual) f(n) es Θ(g(n)) si f(n) = O(g(n)) y f(n) = Ω(g(n)) f ( n) f ∈ Θ( g ) si lim =c<∞ n →∞ g ( n) y
f ∈ Θ( g ) si lim n →∞
g ( n) =c<∞ f ( n)
Algunas propiedades Transitividad: Si f(n) es O(g(n)) y g(n) es O(h(n)) entonces f(n) es O(h(n)) Lo mismo para Ω y Θ Reflexividad: f(n) = O(f(n)) Lo mismo para Ω y Θ Simetría: f(n) es Θ(g(n)) sí y sólo si g(n) es Θ(f(n)) Simetría transpuesta: f(n) es O(g(n)) sí y sólo sí g(n) es Ω(f(n))
Reglas generales para el cálculo de OEs T(switch (C) { case 1:S1|case 2:S2|...|case n:Sn } ) =
T(C) + max{T(S1),T(S2),...,T(Sn)}
Obsérvese que T(C) incluye el tiempo de comparación
con v1, v2 ,..., vn
T(If C { S1 } else { S2 } ) = T(C) + max{T(S1),T(S2)} T(while C { S }) = T(C) + (nº iteraciones)*(T(S) + T(C)) Obsérvese que tanto T(C) como T(S) pueden variar en cada iteración, y por tanto habrá que tenerlo en cuenta para su cálculo
Orden de complejidad Cuando n es lo suficientemente grande… un algoritmo O(1) es más eficiente que un algoritmo O(log n) es más eficiente que un algoritmo O(n) es más eficiente que un algoritmo O(n log n) es más eficiente que un algoritmo O(n2) es más eficiente que un algoritmo O(n3) es más eficiente que un algoritmo O(2n)
Resumiendo La complejidad temporal es la que casi siempre se
analiza a partir de tiempo y repeticiones Notación asintótica para comparar algoritmos Notación O