ANALISIS DE COMPLEJIDAD

ALGORITMICA ITERATIVA CON

NOTACION ASINTOTICA
ANALISIS Y DISEO DE
ALGORITMOS
Docente: Carlos A. Ruiz De La Cruz Melo
Correo: zorroculto69@hotmail.com
El anlisis de los algoritmos que hemos realizado
hasta aqu es muy preciso pero resulta incomodo
para entender que tan eficiente es un algoritmo o
para poder compararlo contra otro algoritmo.

Habitualmente no interesa cuanto tarda
exactamente un algoritmo sino que nos interesa
saber cual es la tasa de crecimiento del algoritmo en
funcin de los datos de entrada.

Para el estudio de algoritmos existe una notacin
muy practica y utilizada universalmente en este tipo
de problemas conocida como la gran O, notacin
asinttica que define el orden de un algoritmo o
Tasa de crecimiento del tiempo que insume el
algoritmo en funcin de la cantidad o tamao de los
datos de entrada.
NOTACION ASINTOTICA
NOTACION ASINTOTICA
La eficiencia asinttica del
algoritmo. Se denomina
asinttica porque analiza el
comportamiento de las
funciones en el lmite, es decir,
su tasa de crecimiento.

El lmite de una funcin f(x), cuando x tiende a c es L si y slo si
para todo c >0 existe un o >0 tal que para todo nmero real x en
el dominio de la funcin
c o < < < L x f c x ) ( 0
La notacin asinttica se describe por medio
de una funcin cuyo dominio es la de los
nmeros naturales (N ) estimado a partir del
tiempo de ejecucin o del espacio de
memoria en base a la longitud de la entrada

La notacin asinttica captura el
comportamiento de la funcin para
valores grandes de N.

NOTACION ASINTOTICA
ORDENES DE COMPLEJIDAD
La mejor tcnica para diferenciar la
eficiencia de los algoritmos es el
estudio de los rdenes de
complejidad.

El orden de complejidad se
expresa generalmente en trminos
de la cantidad de datos procesados
por el programa, denominada n, que
puede ser el tamao dado o
estimado.
Funciones conocidas

n
datos
log
2
n

n nlog
2
n n
2
n
3
2
n

5 3 5 15 25 125 32
10 4 10 40 100 1000 1000
100 7 100 700 10000 10
6

10
30


1000 10 1000 10000 10
6


10
9


10
300


Tiempo
Ejecucin
t(n)

Tamao
mximo del
problema para
10
3
segundos

Tamao
mximo del
problema para
10
4
segundos

Incremento
en los datos
del problema

100n 10 100 1000 (900%)
5n
2
14 45 320 (220%)
n
3
/2 12 27 230 (130%)
2
n
10 13 130 (30%)
100n
5n
2
n
3
/2
2
n
n
t(n)
TIEMPOS DE EJECUCIN
DE 4 PROGRAMAS
ALGUNOS ORDENES DE
COMPLEJIDAD
O(1) orden constante
O(log n) orden logartmico
O(n) orden lineal
O(n
2
) orden cuadrtico
O(n
a
) orden polinomial (a > 2)
O(a
n
) orden exponencial (a > 2)
O(n!) orden factorial
GRAFICA DE FUNCIONES
Funciones que se utilizan
habitualmente a la hora de describir el
coste de los algoritmos
ALGORITMO ACEPTABLE
Para considerar que el coste de un
algoritmo es computacionalmente
aceptable este debe ser, como
mucho , de orden polinmico y con
un grado no demasiado elevado.

Algoritmos con una tasa de
crecimiento superior, por ejemplo
exponencial, se convierten en
soluciones teoricas pero que no se
pueden usar en la practica porque
solo obtienen resultados cuando el
tamao de los datos es muy
pequeo
Sea t, f: N R
+
funciones.

Diremos que t(n) est en el orden de f(n), si
t(n) est acotada superiormente por un
mltiplo real positivo de f(n) para todo n
bien grande.

Existe c y un valor en el umbral n
o
tal
que t(n) cf(n) siempre que n >= n
o
Adems, t(n) e O(f(n)) O grande de
f(n).
NOTACIN ASINTTICA O
( ) ( ) ( ) ( )
)
`

> e - s e e - =

> >
0 0
0 0
/ , * / , / : n n N n n f c n t N n R c R N t n f O
Consideremos las funciones f(n) = log
2
n y g(n) = (n/4)
2
.
NOTACIN ASINTTICA O
As, decir que el tiempo de ejecucin T(n) de un algoritmo es
O(n
2
), que se lee o mayscula de n al cuadrado o tan slo
o de n cuadrado, significa que existen constantes positivas
c y n
0
tales que para n mayor o igual que n
0
, se tiene que:

T(n)cn
2
.


Dicho de otro modo, cuando el tiempo de ejecucin de un
programa es O(f(n)), se dice que tiene una velocidad de
crecimiento f(n)
NOTACIN ASINTTICA O
Sea un problema que sabemos resolver con
algoritmos de diferentes complejidades. Para
compararlos entre si, supongamos que todos ellos
requieren 1 hora de ordenador para resolver un
problema de tamao N=100.

IMPACTO PRACTICO
O(f(n)) N=100 t=2h N=200
log n 1 h 10000 1.15 h
n 1 h 200 2 h
n log n 1 h 199 2.30 h
n
2
1 h 141 4 h
n
3
1 h 126 8 h
2
n
1 h 101 10
30
h
Qu ocurre si
disponemos
del doble de
tiempo o el
doble de los
datos? .
Los algoritmos de tipo polinmico no son
una maravilla, y se enfrentan con
dificultad a problemas de tamao
creciente. La prctica viene a decirnos
que son el lmite de lo "tratable".

Mientras complejidades del orden O(n
2
) y
O(n
3
) suelen ser efectivamente
abordables, prcticamente nadie acepta
algoritmos de orden O(n
100
), por muy
polinmicos que sean.

Cualquier algoritmo por encima de una
complejidad polinmica se dice
"intratable" y slo ser aplicable a
problemas ridiculamente pequeos.
Impacto Practico
IMPACTO PRACTICO
algoritmo tiempo complejidad
f 100 n O(n)
g n
2
O(n
2
)
Por ejemplo, si disponemos de
dos algoritmos para el mismo
problema, con tiempos de
ejecucin respectivos:

asintticamente, "f" es mejor
algoritmo que "g"; pero esto es
cierto a partir de N > 100.

Si nuestro problema no va a
tratar jams problemas de
tamao mayor que 100, es
mejor solucin usar el
algoritmo "g
IMPACTO PRACTICO
an siendo dos algoritmos con idntico
comportamiento asinttico, es obvio que el
algoritmo "f" es siempre 100 veces ms
rpido que el "g" y candidato primero a ser
utilizado.
algoritmo tiempo complejidad
f n O(n)
g 100 n O(n)
si un programa se va a ejecutar muy
pocas veces, los costes de codificacin y
depuracin son los que ms importan,
relegando la complejidad a un papel
secundario.

si a un programa se le prev larga vida,
hay que pensar que le tocar mantenerlo
a otra persona y, por tanto, conviene
tener en cuenta su legibilidad, incluso a
costa de la complejidad de los algoritmos
empleados.

si podemos garantizar que un programa
slo va a trabajar sobre datos pequeos
(valores bajos de N), el orden de
complejidad del algoritmo que usemos
suele ser irrelevante, pudiendo llegar a
ser incluso contraproducente.
IMPACTO PRACTICO
( )
( )
( ) ( ) ( ) ( ) ( ) ( ) n f n g n g n f
n g
n f
Lim
n
O e O e =

pero 0
Propiedades de la Notacin O
( )
( )
( ) ( ) ( ) ( ) ( ) ( ) n f n g n g n f R
n g
n f
Lim
n
O e O e e
>

y
0
( )
( )
( ) ( ) ( ) ( ) ( ) ( ) n f n g n g n f
n g
n f
Lim
n
O e O e + =

y
n
2
O(n
3
)

Solucin

Lim(n
2
/n
3
)=lim 2n/3n
2
=2/6n=0/6=0
n n

Por





n
2
O(n
3
)
Es cierta la siguiente
afirmacin?

( )
( )
( ) ( ) ( ) ( ) ( ) ( ) n f n g n g n f
n g
n f
Lim
n
O e O e =

pero 0
Aplicando LHospital
repetidas veces
n
3
O(n
2
)

Solucin

Lim(n
3
/n
2
)=lim n =
n n

Por





n
3
eO(n
2
)
Es cierta la siguiente
afirmacin?

( )
( )
( ) ( ) ( ) ( ) ( ) ( ) n f n g n g n f
n g
n f
Lim
n
O e O e + =

y
Solucin

2
n+1
O(2
n
)

Es cierto pues

Lim(2
n+1
/2
n
)=2
n
Es cierta la siguiente
afirmacin?

2
n+1
O(2
n
)
Solucin

(n+1)!O(n!)

Es falso pues

Lim((n+1)! / n!)=
n
Es cierta la siguiente
afirmacin?

(n+1)!O(n!)
Solucin

3
n
O(2
n
)

Es falso pues

Lim(3
n
/2
n
))=
n
Es cierta la siguiente
afirmacin?

3
n
O(2
n
)
REGLAS PRCTICAS PARA
CALCULAR LA COMPLEJIDAD
Los algoritmos bien estructurados combinan
las sentencias de alguna de las formas
siguientes
1. sentencias sencillas
2. secuencia (;)
3. decisin (if)
4. bucles
5. llamadas a procedimientos
REGLAS PRCTICAS
Nos referimos a las sentencias
de asignacin, entrada/salida,
etc. siempre y cuando no
trabajen sobre variables
estructuradas cuyo tamao
este relacionado con el
tamao N del problema.

La inmensa mayora de las
sentencias de un algoritmo
requieren un tiempo
constante de ejecucin,
siendo su complejidad O(1).
Sentencias sencillas
REGLAS PRCTICAS
Secuencia (;)
La complejidad de una serie de
elementos de un programa es
del orden de la suma de las
complejidades individuales,
aplicndose las operaciones
arriba expuestas.
Decisin (if)
La condicin suele ser
de O(1), complejidad a
sumar con la peor
posible, bien en la
rama THEN, o bien en
la rama ELSE. En
decisiones multiples
(ELSE IF, SWITCH
CASE), se tomara la
peor de las ramas.
REGLAS PRCTICAS
REGLAS PRCTICAS
Bucles
En los bucles con contador
explcito, podemos
distinguir dos casos, que el
tamao N forme parte de
los lmites o que no.

Si el bucle se realiza un
nmero fijo de veces,
independiente de N,
entonces la repeticin slo
introduce una constante
multiplicativa que puede
absorberse.
for (int i= 0; i < K; i++) {
algo_de_O(1)
}

K*O(1) = O(1)
Reglas Prcticas
Bucles
Si el tamao N aparece como lmite de
iteraciones
for (int i= 0; i < N; i++) {
algo_de_O(1)
}

N * O(1) = O(n)
for (int i= 0; i < N; i++) {
for (int j= 0; j < N; j++) {
algo_de_O(1)
}
}

Tendremos N * N * O(1) = O(n
2
)
a)
b)
Reglas Prcticas
Bucles
for (int i= 0; i < N; i++) {
for (int j= 0; j < i; j++) {
algo_de_O(1)
}
}
el bucle exterior se realiza N veces, mientras que el interior se
realiza 1, 2, 3, ... N veces respectivamente.

En total, 1 + 2 + 3 + ... + N = N*(1+N)/2 e O(n
2
)
Reglas Prcticas
A veces aparecen bucles
multiplicativos, donde la evolucin
de la variable de control no es lineal
(como en los casos anteriores)
c= 1;
while (c < N) {
algo_de_O(1)
c= 2*c;
}
El valor incial de "c" es 1, siendo
"2
k
" al cabo de "k" iteraciones.

El nmero de iteraciones es tal que
2
k
>= N => k= (log
2
(N)) [el entero
inmediato superior] y, por tanto, la
complejidad del bucle es

O(log n).
c= 2x1 = 2.. 2
1

c=2x2= 4.. 2
2

c=2x4 = 8 2
3
:
Reglas Prcticas
c= N;
while (c > 1) {
algo_de_O(1)
c= c / 2;
}
Un razonamiento
anlogo nos lleva a
log
2
(N) iteraciones y,
por tanto, a un orden
O(log n) de complejidad
for (int i= 0; i < N; i++) {
c= i;
while (c > 0) {
algo_de_O(1)
c= c/2;
}
}
tenemos un bucle interno
de orden O(log n) que se
ejecuta N veces, luego el
conjunto es de orden
O(nlog n)
Dado el siguiente algoritmo,
determina su complejidad.
Ejercicio 1
funcion valor(n): entero
para i1 hasta N hacer
para j 1 hasta 20 hacer
aux j * 2
aux aux* i + r
finpara
finpara
retornar aux
finvalor
Dado el siguiente algoritmo, determina su complejidad.
Solucin 1
funcion valor(n): entero
para i1 hasta N hacer
para j 1 hasta 20 hacer
aux j * 2
aux aux* i + r
finpara
finpara
retornar aux
finvalor
Funcion valor(n): entero
r 1
para i 1 hasta n hacer
para j 1 hasta n hacer
si i < j entonces
aux i + j
sino
auxi - j
finsi
finpara
finpara
retornar aux
finvalor
Dado el siguiente algoritmo, determine su complejidad.
Ejercicio 2
Funcion valor(n): entero
r 1
para i 1 hasta n hacer
para j 1 hasta n hacer
si i < j entonces
aux i + j
sino
auxi - j
finsi
finpara
finpara
retornar aux
finvalor
Dado el siguiente algoritmo, determina su complejidad.
Solucin 2
funcion valor(n): entero
desde i1 hasta n hacer
desde j 1 hasta i hacer
si i < j entonces
aux i + j
si i + 2 < j entonces
aux aux * 2
finsi
finsi
finpara
finpara
retornar a ux
finvalor
Dado el siguiente algoritmo,
determine su complejidad.
Ejercicio 3
funcion valor(n): entero
desde i1 hasta n hacer
desde j 1 hasta i hacer
si i < j entonces
aux i + j
si i + 2 < j entonces
aux aux * 2
finsi
finsi
finpara
finpara
retornar aux
finvalor
Dado el siguiente algoritmo, determina su complejidad.
Solucin 3
para i1 hasta n-1 hacer (* 1 *)
para jn hasta i+1 paso -1 hacer (* 2 *)
if a[j-1]>a[j] entonces (* 3 *)
tempa[j-1] (* 4 *)
a[j-1]a[j] (* 5 *)
a[j]temp (* 6 *)
fin (* 7 *)
fin (* 8 *)
fin
Calcular sus tiempos de ejecucin en el
mejor, peor, y caso medio.
Ejercicio 4
Se calcula primero el nmero de
operaciones elementales (OE) que
se realizan:

En la lnea (1) se ejecutan 3 OE
(una asignacin, una resta y una
comparacin) en cada una de las
iteraciones del bucle ms otras 3 al
final, cuando se efecta la salida
del para.
Igual ocurre con la lnea (2),
tambin con 3 OE (una asignacin,
una suma y una comparacin) por
iteracin, ms otras 3 al final del
bucle.
En la lnea (3) se efecta una
condicin, con un total de 4 OE
(una diferencia, dos accesos a un
vector, y una comparacin).
Las lneas (4) a (6) slo se
ejecutan si se cumple la condicin
de la lnea (3), y realizan un total
de 9 OE: 3, 4 y 2 respectivamente.
Solucin 4:
para i1 hasta n-1 hacer (* 1 *)
para jn hasta i+1 paso -1 hacer (* 2 *)
if a[j-1]>a[j] entonces (* 3 *)
tempa[j-1] (* 4 *)
a[j-1]a[j] (* 5 *)
a[j]temp (* 6 *)
fin (* 7 *)
fin (* 8 *)
fin
MEJOR CASO

En el caso mejor para el
algoritmo la condicin de la
lnea (3) ser siempre falsa, y
no se ejecutarn nunca las
lneas (4), (5) y (6). As, el bucle
ms interno realizar (ni)
iteraciones, cada una de ellas
con 4 OE (lnea 3), ms las 3
OE de la lnea (2). Por tanto, el
bucle ms interno realiza un
total de
OE, siendo el 3 adicional por la
condicin de salida del bucle.
para i1 hasta n-1 hacer (* 1 *)
para jn hasta i+1 paso -1 hacer (* 2 *)
if a[j-1]>a[j] entonces (* 3 *)
tempa[j-1] (* 4 *)
a[j-1]a[j] (* 5 *)
a[j]temp (* 6 *)
fin (* 7 *)
fin (* 8 *)
fin
MEJOR CASO
A su vez, el bucle externo
repetir esas 7(ni)+3 OE
en cada iteracin, lo que
hace que el nmero de OE
que se realizan en el
algoritmo sea:
para i1 hasta n-1 hacer (* 1 *)
para jn hasta i+1 paso -1 hacer (* 2 *)
if a[j-1]>a[j] entonces (* 3 *)
tempa[j-1] (* 4 *)
a[j-1]a[j] (* 5 *)
a[j]temp (* 6 *)
fin (* 7 *)
fin (* 8 *)
fin
PEOR CASO
En el caso peor, la condicin de
la lnea (3) ser siempre
verdadera, y las lneas (4), (5) y
(6) se ejecutarn en todas las
iteraciones. Por tanto, el bucle
ms interno realiza
OE. El bucle externo realiza
aqu el mismo nmero de
iteraciones que en el caso
anterior, por lo que el nmero de
OE en este caso es:
para i1 hasta n-1 hacer (* 1 *)
para jn hasta i+1 paso -1 hacer (* 2 *)
if a[j-1]>a[j] entonces (* 3 *)
tempa[j-1] (* 4 *)
a[j-1]a[j] (* 5 *)
a[j]temp (* 6 *)
fin (* 7 *)
fin (* 8 *)
fin
CASO MEDIO
En el caso medio, la condicin
de la lnea (3) ser verdadera
con probabilidad 1/2. As, las
lneas (4), (5) y (6) se ejecutarn
en la mitad de las iteraciones del
bucle ms interno, y por tanto
realiza
OE. El bucle externo realiza
aqu el mismo nmero de
iteraciones que en el caso
anterior, por lo que el nmero
de OE en este caso es:
para i1 hasta n-1 hacer (* 1 *)
para jn hasta i+1 paso -1 hacer (* 2 *)
if a[j-1]>a[j] entonces (* 3 *)
tempa[j-1] (* 4 *)
a[j-1]a[j] (* 5 *)
a[j]temp (* 6 *)
fin (* 7 *)
fin (* 8 *)
fin
NOTACIN ASINTTICA
Sea t, f: N R
+
funciones.

Diremos que t(n) est en Omega de f(n),
si t(n) est acotada inferiormente por un
mltiplo real positivo de f(n) para todo n
bien grande.

Existe d y un valor en el umbral n
o
tal
que t(n) >= df(n) siempre que n >= n
o
Adems, t(n) e O(f(n)) O grande
de f(n).
( ) ( ) ( ) ( )
)
`

> e - > e e - = O

> >
0 0
0 0
/ , * / , / : n n N n n f d n t N n R d R N t n f
(n/4)
2
e O(Log
2
n)
g(n) =(n/4)
2

n
t(n)
a
b
f(n)=Log
2
n
NOTACIN ASINTTICA O
Consideremos las funciones f(n) = log
2
n y g(n) = (n/4)
2
.
La funcin omega grande, se utiliza
para especificar una cota inferior para
la velocidad del crecimiento, de una
funcion F(n) cuando esta en funcion de
n.

La cota inferior asinttica tiene utilidad
en Teora de la complejidad
computacional a la hora de calcular la
complejidad del mejor caso para los
algoritmos.
NOTACIN ASINTTICA
( )
( )
( ) ( ) ( ) ( ) ( ) ( ) n f n g n g n f R
n g
n f
Lim
n
O e O e e
>

y
0
( )
( )
( ) ( ) ( ) ( ) ( ) ( ) n f n g n g n f
n g
n f
Lim
n
O e O e =

pero 0
( )
( )
( ) ( ) ( ) ( ) ( ) ( ) n f n g n g n f
n g
n f
Lim
n
O e O e + =

y
PROPIEDADES DE LA NOTACIN O
funcion MXIMO ( v, n) : entero
entero: i, max

maxv[1]
para i 2 hasta n hacer
si v[i]>max entonces
max v[i]
finsi
finpara
retornar max
finMAXIMO
Ejercicio 5
Determinar costo de ejecucin
) ( ) 1 2 ( 1 1 1
2
n n n Ci
n
i
O e = + + = + =

=
) ( 1 2 2 ). 1 2 ( 1 2 1
2
n n n Cs
n
i
O e = + + = + =

=
) (n O e
NOTACIONES ASINTTICAS
Notacin Theta(u): Entonces t(n)
est en Theta de f(n) si y solo s t(n)
est en Orden exacto de f(n) y t(n)
est en Omega de f(n).

Adems lo denotamos t(n) e u(f(n))
u grande de f(n).
( ) ( ) ( ) ( ) ( )
)
`

> e - > > e e - = O

> >
0 0
0 0
/ , * * / , , / : n n N n n f d n t n f c N n R d c R N t n f
PROPIEDADES DE LA NOTACIN u
( )
( )
( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) n g n f n g n f n g n f R
n g
n f
Lim
n
O e O e O e e
>

y
0
( )
( )
( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) n g n f n g n f n g n f
n g
n f
Lim
n
O e O e O e =

y 0
( )
( )
( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) n g n f n g n f n g n f
n g
n f
Lim
n
O e O e O e + =

y
RELACIONES ENTRE O O u
Notacin O (big-omicron) caso peor
Notacin (omega) caso mejor
Notacin (big-theta) caso promedio
EJERCICIO DE LABORATORIO
En los algoritmos de clasificacin iterativos y bajo
arreglos:

Ordenacion Burbuja
Ordenacion por insercion

1. Encuentre el caso medio, el peor y mejor caso

2. Luego implemente ambos algoritmos en C++ y
java. Pruebe cada programa tanto con datos
ordenados, desordenados aleatoriamente y en
sentido inverso y no se olvide para cada caso
tomar tiempos.

3. Despus verifique si existe alguna relacin entre
sus ecuaciones halladas para el caso medio, peor
y mejor caso) con los tiempos reales de sus
implementaciones en java y C++.