Anlisis de Algoritmos

y complejidad
computacional
Ing. Informtico Mitchell
Blancas

Facultad de CC.FF. - Escuela de

Informtica

Eficiencia de Algoritmos
Siempre que elaboremos un algoritmo debemos preocuparnos en
analizar su eficiencia.
Esto implica determinar la cantidad de recursos que utiliza:
a) Cantidad de memoria
b) Tiempo de cmputo requerido
Estos dos parmetros nos permiten comparar dos algoritmos que
resuelven el problema.

Facultad de CC.FF. - Escuela de

Informtica

Cantidad de memoria
Se puede determinar fcilmente por el nmero y tamao de las
variables.

Tiempo de ejecucin
Se determina por el nmero de operaciones elementales.

Compromiso espacio- tiempo

Se reduce el espacio de almacenamiento con un
incremento del tiempo de ejecucin

Facultad de CC.FF. - Escuela de

Informtica

Medida del Tiempo de Ejecucin

El tiempo de ejecucin depende de la cantidad de datos a procesar.
Sin embargo, el tiempo de reloj depende de la velocidad de la
mquina, el software que se esta ejecutando (sistema operativo y
otros), por lo que no puede ser una medida adecuada.

Es por esto que necesitamos una medida independiente de la

implementacin, entonces asumimos el modelo de computacin
llamado Mquina de Acceso Directo (MAD). Aqu se usan un
conjunto bsico de operaciones una detrs de otra, sin operaciones
concurrentes (en simultneo).

Facultad de CC.FF. - Escuela de

Informtica

Sin usar frmula calcule la

suma de los primeros n
Pseudocdigo
nmeros
naturales
Leer (n)
suma=0
Para i=1 hasta i=n
suma=suma +i
Fin para
Imprimir (suma)

t1 se
t2 se
t3 se
veces
t4 se
veces

ejecuta 1 vez
ejecuta 1 vez
ejecuta n
ejecuta n

Tiempo total de ejecucin = t1 + t2 + t3.n + t4.n +

t5 se ejecuta 1 vez
t5
T(n) = (t1 + t2 + t5)+ (t3 +
Note que los tiempos son valores que se pueden obtener una vez
t4).n
conocida la mquina en la que se ejecutar.
El tiempo total de clculo depende del tamao de la entrada n, sea
cual fuera la mquina en la que correr. As que podramos decir
que este algoritmo tiene tiempo de ejecucin que depende de n.

Facultad de CC.FF. - Escuela de

Informtica

La Notacin
Asinttica

La notacin asinttica se
comportamiento de una
Adems, puede indicar
aproximadamente iguales
rpidamente que la otra.

emplea para mostrar el

funcin respecto a otra.
que dos funciones son
o que una crece mas

Facultad de CC.FF. - Escuela de

Informtica

Cota superior
asinttica

Es una funcin que sirve

como cota superior de otra
funcin cuando el argumento
tiende al infinito

La Notacin O
Grande
Para
expresar la cota superior asinttica de una funcin, se
usa la notacin O Grande. Matemticamente:

La funcin f(x) esta acotada por O( g(x) ), si existe una

constante c, a partir de un punto inicial (+), de tal forma que si
tomamos cualquier otro punto la funcin f(x) es menor que la
otra.
Facultad de CC.FF. - Escuela de
Informtica

Cota inferior
asinttica
Es una funcin que sirve como

cota inferior de otra funcin

cuando el argumento tiende al
infinito

La Notacin Omega
Grande
Para expresar la cota inferior asinttica de una funcin, se
usa la notacin Grande. Matemticamente:

La funcin f(x) esta acotada inferiormente por ( g(x) ), si

existe una constante c, a partir de un punto inicial (+), de tal
forma que si tomamos cualquier otro punto la funcin f(x) es
Facultad de CC.FF. - Escuela de
mayor que la otra.
Informtica

Cota ajustada
asinttica

Es una funcin que sirve tanto de

cota superior como de cota
inferior de otra funcin cuando el
argumento tiende al infinito.

La Notacin Theta
Grande
Para expresar la cota ajustada asinttica de una funcin, se
usa la notacin Grande. Matemticamente:

La funcin f(x) puede ser acotada por ( g(x) ), tanto inferior

como superiormente, cuando usamos constantes diferentes.
Facultad de CC.FF. - Escuela de
Informtica

Cota Superior asinttica usa notacin

O Grande
Cota Inferior asinttica usa notacin
Omega Grande
Cota Ajustada asinttica usa notacin
Theta Grande

Relaciones entre O,
y

Facultad de CC.FF. - Escuela de

Informtica

10

Entonces pues, dado un programa nos interesa obtener una

funcin que represente la cantidad de unidades de tiempo, para
luego acotar esta funcin. A esto se le conoce como clculo
de la complejidad de un algoritmo.

Reglas para el clculo de

complejidad
Aunque no hay una receta que funcione siempre, daremos

algunas
pautas de cmo calcular la complejidad de un algoritmo para diferentes
casos:
Sentencias Simples
Condicionales
Bucles
Llamadas a funcin
Secuencias de instrucciones

Facultad de CC.FF. - Escuela de

Informtica

11

a) Sentencias simples
Cuando en un algoritmo intervienen sentencias simples, como
asignacin, entrada o salida e datos, requieren un tiempo
constante de ejecucin por lo que su complejidad ser:
O(1)
Esto no incluye aquellas variables cuyo tamao esta relacionado
con el tamao del problema.

Por ejemplo no puedo considerar la suma de dos nmeros

gigantes como sentencia simple.

Facultad de CC.FF. - Escuela de

Informtica

12

b)
Condicionales

La evaluacin de una expresin condicional requiere por lo

general un tiempo constante de ejecucin por lo que su
complejidad ser O(1).
La complejidad que debe sumarse con la peor de las ramas ya
sea las instrucciones a ejecutar de ser verdadera o falsa la
condicin.
En decisiones mltiples (else if, switch case) se tomar la
peor de las ramas.

c) Bucles

Si el bucle tiene un contador de tamao conocido entonces se

multiplica esa cantidad de veces por la sentencia de peor
complejidad.

Facultad de CC.FF. - Escuela de

Informtica

13

d) Llamadas a funciones
Viene dada por la complejidad de sus sentencias. El costo de la
invocacin a la funcin y su retorno se consideran constantes y
se puede obviar para el anlisis asinttico.
El clculo de la complejidad de una funcin se puede complicar
si se trata de funciones recursivas, las cuales estudiaremos mas
adelante.

e) Secuencias de instrucciones
La complejidad de una secuencia de instrucciones es la suma de
sus complejidades individuales, debiendo aplicar todo lo
anterior.

Facultad de CC.FF. - Escuela de

Informtica

14

Jerarqua de Ordenes de
Complejidades
O(1)

Orden constante

O(log n)

Orden logartmico

O(n)

Orden lineal

O(n log n)

Orden cuasi-lineal

O(n2)
O(n3)
O(na)

Orden cuadrtico
Orden cbico
Orden polinmico

O(2n)

Orden exponencial

O(n!)

Orden factorial

O(1):
Complejidad
constante.
instrucciones se ejecutan una vez.

Cuando

las

O(log n): Complejidad logartmica. Esta suele

aparecer en determinados algoritmos con iteracin o
recursin no estructural, ejemplo la bsqueda binaria.
O(n): Complejidad lineal. Es una complejidad buena y
tambin muy usual. Aparece en la evaluacin de
bucles simples siempre que la complejidad de las
instrucciones interiores sea constante.
O(n log n): Complejidad cuasi-lineal. Se encuentra en
algoritmos de tipo divide y vencers como por
ejemplo en el mtodo de ordenacin mergesort y se
considera una buena complejidad. Si n se duplica, el
tiempo de ejecucinFacultad
es ligeramente
mayor del doble.
de CC.FF. - Escuela de
Informtica

16

O(n2): Complejidad cuadrtica. Aparece en bucles o

ciclos doblemente anidados. Si n se duplica, el tiempo
de ejecucin aumenta cuatro veces.
O(n3): Complejidad cbica. Suele darse en bucles con
triple anidacin. Si n se duplica, el tiempo de
ejecucin se multiplica por ocho. Para un valor grande
de n empieza a crecer dramticamente.
O(na): Complejidad polinmica (a > 3). Si a crece, la
complejidad del programa es bastante mala.
O(2n): Complejidad exponencial. No suelen ser muy
tiles en la prctica por el elevadsimo tiempo de
ejecucin. Se dan en subprogramas recursivos que
contengan dos o ms llamadas internas.
Facultad de CC.FF. - Escuela de
Informtica

17

Facultad de CC.FF. - Escuela de

Informtica

18

Ejemplo
Un programa emplea 100n unidades de tiempo
para ser ejecutado, otro programa emplea 2n2.
Cual de los dos programas es mejor?
Depende del tamao del problema.
Para n < 50, el programa con tiempo 2n2 es
mejor.
Para problemas con entrada de datos
pequeo, es preferible usar el programa cuyo
tiempo de ejecucin es O(n2).
Sin embargo, cuando n crece, el programa con
tiempo de ejecucin O(n2) emplea mas tiempo
que el programa O(n).
Facultad de CC.FF. - Escuela de
Informtica

19

Calculo de la Complejidad en
algoritmos iterativos

Facultad de CC.FF. - Escuela de

Informtica

20

Calcular la complejidad del

siguiente algoritmo iterativo
funcion( int n)
{
int i, j, k, x;
x=0;
para i=1 hasta n-1 hacer
para j=i+1 hasta n
hacer
para k=1 hasta j
hacer
x=x+1
}
Facultad de CC.FF. - Escuela de
Informtica

21

El bucle mas interno repite j veces una instruccin de tiempo O(1)

j

o sea la instruccin simple x=x+1 se realiza

j veces.
funcion(
int n)
{

k=1
El segundo bucle mas interno
n
j = n (n+1)/2 i (i+1)/2
j=i+1

int i, j, k, x;
x=0;
para i=1 hasta n-1
hacer
para j=i+1 hasta
n hacer

El tercer bucle (el externo) tenemos

hasta j hacer
n-1
n-1
n-1
1
[ n (n+1)/2 i (i+1)/2 ] = n (n+1)/2 i (i+1)/2
}
i=1
i=1
i=1

para k=1
x=x+

n-1

= (n-1) n (n+1) / 2 - 1/2 (i2+i)

i=1
n-1

= (n-1) n (n+1) / 2 - 1/2 (i2+i)

i=1

= (n-1) n (n+1) / 2 - 1/2. (n-1)(n)(2n-1)/6

1/2.(n-1)n/2
= n(n2-1)/3
Facultad de CC.FF. - Escuela de
O(n3) Informtica

22

Calculo de la complejidad
algoritmos
recursivos(RECURRENCIAS)

Facultad de CC.FF. - Escuela de

Informtica

en

23

Calcular la complejidad del

siguiente algoritmo recursivo

Facultad de CC.FF. - Escuela de

Informtica

24

Calcular la complejidad del

siguiente algoritmo recursivo

Paso1:

Facultad de CC.FF. - Escuela de

Informtica

25

Calcular la complejidad del

siguiente algoritmo recursivo
T(n) =2 T(n/2)+n

Facultad de CC.FF. - Escuela de

Informtica

26

Calcular la complejidad del

siguiente algoritmo recursivo
T(n) =2 T(n/2)+n

Facultad de CC.FF. - Escuela de

Informtica

27

Calcular la complejidad del

siguiente algoritmo recursivo
T(n) =2 T(n/2)+n
T(n) = 2[2 T(n/22)+n/2] +n =
22T(n/22)+2n

Facultad de CC.FF. - Escuela de

Informtica

28

Calcular la complejidad del

siguiente algoritmo recursivo
T(n) =2 T(n/2)+n
T(n) = 2[2 T(n/22)+n/2] +n =
22T(n/22)+2n

Facultad de CC.FF. - Escuela de

Informtica

29

Calcular la complejidad del

siguiente algoritmo recursivo
T(n) =2 T(n/2)+n
T(n) = 2[2 T(n/22)+n/2] +n =
22T(n/22)+2n
T(n) = 22 [2T(n/ 23) +n/ 22] +2n =
23T(n/23)+3n

Facultad de CC.FF. - Escuela de

Informtica

30

Calcular la complejidad del

siguiente algoritmo recursivo
T(n) =2 T(n/2)+n
T(n) = 2[2 T(n/22)+n/2] +n =
22T(n/22)+2n
T(n) = 22 [2T(n/ 23) +n/ 22] +2n =
23T(n/23)+3n
.
.
.
Facultad de CC.FF. - Escuela de
Informtica

31

Calcular la complejidad del

siguiente algoritmo recursivo
T(n) =2 T(n/2)+n
T(n) = 2[2 T(n/22)+n/2] +n = 22T(n/22)+2n
T(n) = 22 [2T(n/ 23) +n/ 22] +2n =
23T(n/23)+3n
.
.
.
T(n) = 2kT(n/2k)+kn ; artificio: 2k =n k=
log (n)
Facultad de CC.FF. - Escuela de
Informtica

32

Calcular la complejidad del

siguiente algoritmo recursivo
T(n)
T(n)
T(n)
.
.
.
T(n)
(n)
T(n)

=2 T(n/2)+n
= 2[2 T(n/22)+n/2] +n = 22T(n/22)+2n
= 22 [2T(n/ 23) +n/ 22] +2n = 23T(n/23)+3n

= 2kT(n/2k)+kn ; artificio: 2k =n k= log

= n*T(1)+ log (n)*n
Facultad de CC.FF. - Escuela de
Informtica

33

Calcular la complejidad del

siguiente algoritmo recursivo
T(n)
T(n)
T(n)
.
.
.
T(n)
T(n)
T(n)

=2 T(n/2)+n
= 2[2 T(n/22)+n/2] +n = 22T(n/22)+2n
= 22 [2T(n/ 23) +n/ 22] +2n = 23T(n/23)+3n

= 2kT(n/2k)+kn ; artificio: 2k =n k= log (n)

= n*T(1)+ log (n)*n
= O(n*T(1)+ log (n)*n) = O (n*log (n))
Facultad de CC.FF. - Escuela de
Informtica

34

Calcular la complejidad del

siguiente algoritmo recursivo
T(n)
T(n)
T(n)
.
.
.
T(n)
T(n)
T(n)

=2 T(n/2)+n
= 2[2 T(n/22)+n/2] +n = 22T(n/22)+2n
= 22 [2T(n/ 23) +n/ 22] +2n = 23T(n/23)+3n

= 2kT(n/2k)+kn ; artificio: 2k =n k= log (n)

= n*T(1)+ log (n)*n
= O(n*T(1)+ log (n)*n) = O (n*log (n))
Facultad de CC.FF. - Escuela de
Informtica

35