ANLISIS Y DISEO DE ALGORITMOS

Anlisis de Algoritmos
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.
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 sin
incrementar el tiempo de ejecucin
Lo que consideramos en este curso

Nosotros limitaremos nuestro anlisis al tiempo de

ejecucin, pues la memoria es barata en comparacin
al tiempo del procesador, y adems es ms fcil calcular
cuanta memoria se necesitar.
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.
 Sin usar frmula calcule la
suma de los primeros n
nmeros
PsuedoCdigo
Leer (n)
naturales
t1 se ejecuta 1 vez
suma=0 t2 se ejecuta 1 vez
Para (i=1 hasta i=n) t3 se ejecuta n
suma=suma +i veces
Imprimir (suma) t4 se ejecuta n
veces
Tiempo total de ejecucin = t1 +t5 t2 se
+ t3.n + t4.n
ejecuta +
1 vez
t5
T(n) = (t1 + t2 + t5)+ (t3 +
Note que
t4).los
n tiempos son valores que se pueden obtener una vez
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.
La Notacin
Asinttica
La notacin asinttica se emplea para mostrar el
comportamiento de una funcin respecto a otra.

Puede indicar que dos funciones son aproximadamente

iguales o que una crece mas rpidamente que la otra.
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.
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
mayor que la otra.
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.
Relaciones entre O, y

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
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)

Nota:
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.
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).
En decisiones mltiples (else if, switch case) se tomar la
complejidad de 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.
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.
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) Orden cuadrtico
O(n3) Orden cbico
O(na) Orden polinmico
O(2n) Orden exponencial
O(n!) Orden factorial
O(1): Complejidad constante. Cuando las instrucciones se
ejecutan una vez.

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 quicksort y se considera una buena
complejidad. Si n se duplica, el tiempo de ejecucin es
ligeramente mayor del doble.
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.
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
fin_para
fin_para
fin_para
}
El bucle mas interno repite j veces una instruccin de tiempo O(1)
j
1 o sea la instruccin simple x=x+1
funcion(se
intrealiza
n){ j
veces. int i, j, k, x;
x=0;
k=1 para i=1 hasta n-1
hacer
para j=i+1 hasta
n hacer
para k=1
hasta j hacer
x=x+
1
fin_para
fin_para
fin_para
}
El bucle mas interno repite j veces una instruccin de tiempo O(1)
j
funcion( int n){
1 o sea la instruccin simple x=x+1 se realiza j int i, j, k, x;
x=0;
veces. para i=1 hasta n-1
k=1 hacer
para j=i+1 hasta
El segundo bucle mas interno:
n n hacer
j = n (n+1)/2 i (i+1)/2
j=i+1 para k=1
hasta j hacer
x=x+
1
fin_para
fin_para
fin_para
}
 funcion(
El bucle mas interno repite j veces una instruccin int n){ O(1)
de tiempo
int i, j, k, x;
j
x=0;
1 o sea la instruccin simple x=x+1 se realiza j para i=1 hasta n-1
hacer
veces. para j=i+1 hasta
k=1 n hacer
para k=1
El segundo bucle mas interno:
n hasta j hacer
j = n (n+1)/2 i (i+1)/2
j=i+1 x=x+
El tercer bucle (el externo) tenemos: 1
n-1 n-1 n-1
[ n (n+1)/2 i (i+1)/2 ] = n (n+1)/2 i (i+1)/2 fin_para
i=1 i=1 i=1
fin_para
n-1
fin_para
= (n-1) n (n+1) / 2 - 1/2 (i2+i)
}
i=1

n-1 n-1
= (n-1) n (n+1) / 2 - 1/2 [ i2 + i ]
i=1 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
O(n3)
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+2 hasta
n hacer
para k=1
hasta j hacer
x=x+ Complejidad:
k
fin_para
fin_para O(?)
fin_para
}
Calcular la complejidad del
siguiente algoritmo iterativo

funcion( int n){

para(k=1; k<=n;
k*=2)
para(j=0; j<n; j+
+) Complejidad:
sum1++;
fin_para
fin_para
O(?)
}