ALGORITMICA III

Capitulo I
ANALISIS DE ALGORITMOS

Ivn Medrano Valencia
Universidad Nacional de San Antonio Abad del
Cusco
Departamento Acadmico de Informtica
ANALISIS DE ALGORITMOS
Un algoritmo es un conjunto de instrucciones sencillas,
claramente especificado, que se debe seguir para
resolver un problema.
Puede haber varios algoritmos que resuelven el mismo
problema.
Pero cul de ellos es mejor en trminos de tiempo de
ejecucin y de uso de memoria?
Un algoritmo que resuelve un problema, pero tarda un
ao en hacerlo, difcilmente ser de utilidad.
Por otro lado un algoritmo que necesita un gigabyte de
memoria principal no es til.

ANALISIS DE ALGORITMOS
Para determinar que algoritmo es mejor,
tomaremos en consideracin dos aspectos:
El coste o complejidad espacial, es decir la cantidad de
memoria que consume.
El coste o complejidad temporal, es decir, el tiempo
que necesita para resolver un problema.
Ambos determinan el coste o complejidad
computacional. No siempre coincidirn consumo
espacial ptimo con mnimo tiempo de ejecucin.

Complejidad Temporal
Es posible calcular o estimar el tiempo de
ejecucin de un algoritmo a partir d del cdigo
fuente, sin necesidad de implementar y
ejecutar los programas?
Vamos a estudiar esta posibilidad
considerando tres algoritmos que solucionan
un mismo problema: el clculo del cuadrado
del nmero 10.
Dependencia del tiempo con el coste de las
operaciones elementales
Producto

Inicio
m 10*10
Escribir M
Fin

Suma

Inicio
m 0
para(i0; i<10;i++)
mm+10
Escribir m
Fin
Incremento
Inicio
m 0
para(i0; i<10; i++)
para(j0; j<10;j++)
m++;
Escribir m
Fin
Cual de los tres se
ejecutar ms
rpido
Dependencia del tiempo con el coste de las
operaciones elementales
A simple vista diramos que el primero, pues
ocupa menos lneas y resuelve directamente el
problema. Pero debemos de pensar un poco la
respuesta: eso sera cierto si cuesta menos
tiempo efectuar una multiplicacin que 10 sumas
o 100 incrementos. Normalmente, el producto es
una operacin ms lenta que la suma, y sta es
ms costosa que el incremento. Supongamos que
en nuestro computador cada operacin bsica
tarda lo que se indica enla sigte. tabla (1 s es
una millonsima de segundo)
Dependencia del tiempo con el coste de las
operaciones elementales
(No tendremos en cuenta el tiempo de impresin de resultados en aras de
simplificar la exposicin.)
Cada programa efecta un nmero diferente de productos, sumas e
incrementos:
Dependencia del tiempo con el coste de las
operaciones elementales
Y si el coste fuera diferente, como por ejemplo el
De la sgte. Tabla:
Qu programa sera ms rpido en este otro escenario?
En ese caso, producto sera el ms
rpido e incremento el ms lento
Dependencia del tiempo con el coste de las
operaciones elementales
Y si sumar fuese ms rpido? Pongamos por caso que los
tiempos de ejecucin de cada operacin fueran stos:
Entonces resultara vencedor el programa que calcula 10
2
sumando
(tardara 83 s):
Dependencia del tiempo con el coste de las
operaciones elementales
No es tan fcil, pues, decidir qu programa es
ms rpido, al menos no si queremos tener en
cuenta el coste de cada instruccin ya que
ste depende del computador.
Los programas estudiados presentan una
aplicacin muy pobre: se limitan a resolver el
problema del clculo de 10 al cuadrado.
Generalicmoslos para resolver el problema
de calcular n
2
, siendo n un entero cualquiera:
Dependencia del tiempo con el coste de las
operaciones elementales
Inicio
Leer n
m n*n
Escribir m
Fin

Inicio
Leer n
m 0
para(i0; i<n;i++)
mm+n
Escribir m
Fin
Inicio
Leer n
m 0
para(i0; i<n; i++)
para(j0; j<n; j++)
m++;
Escribir m
Fin
Producto Suma
Incremento
El clculo de 10
2
es un caso particular del clculo de n
2
.
Decimos que el caso n = 10 es una
instancia del problema de calcular n
2
. En principio, cuanto
mayor es el valor de n, ms costoso es resolver el problema.
Por ejemplo, la instancia
n = 100 es ms difcil de resolver que la instancia n = 10. En
este caso decimos, adems, que n es el tamao del problema.
Dependencia del tiempo con el coste de las
operaciones elementales
Podemos expresar el tiempo de ejecucin de los tres programas como una funcin
del valor de n, es decir, del tamao.
Anotaremos al margen el nmero de operaciones que implica la ejecucin de
cada lnea del programa.
Inicio
Leer n
m n*n
Escribir m
Fin

1 producto y 1 asignacin
Operaciones Veces
Producto
Dependencia del tiempo con el coste de las
operaciones elementales
Inicio
Leer n
m 0
para(i0; i<n; i++)
mm+n
Escribir m
Fin
Suma
1 asignacin
Operaciones Veces
1 asignacin, n+1 comparaciones y n incrementos
1 suma y 1 asignacin n veces
Dependencia del tiempo con el coste de las
operaciones elementales
Inicio
Leer n
m 0
para(i0; i<n; i++)
para(j0; j<n; j++)
m++;
Escribir m
Fin
Incremento
1 asignacin
1 asignacin, n+1 comparaciones y n incrementos
1 asignacin, n+1 comparaciones y n incrementos n veces
1 incremento n
2
veces
Operaciones Veces
RESUMIENDO
Dependencia del tiempo con el coste de las
operaciones elementales
Si representamos grficamente la evolucin del coste
temporal en funcin del tamao del problema, nos haremos
una idea de cuan bueno o malo es un algoritmo conforme se
enfrenta a problemas ms y ms grandes.
En el supuesto de que un producto cueste 342 s, una suma
31s y 1 s el resto de operaciones, la evolucin del coste
con el tamao se puede representar grficamente as:
Dependencia del tiempo con el coste de las
operaciones elementales
Queda patente que para cada tamao hay un algoritmo
ms rpido, pero no siempre el mismo. Hasta n = 10, el
mejor es incremento, en n = 10, los tres son igual de
rpidos, y a partir de n = 10 siempre es ms rpido
producto. Es ms, cuanto mayor es n, mejor resulta
producto y peor incremento.
Dependencia del tiempo con el coste de las
operaciones elementales
Vimos que haba configuraciones de los tiempos de cada operacin que hacan que suma fuera
ms rpido cuando n toma el valor 10. Consideremos, por ejemplo, la siguiente combinacin:

Dependencia del tiempo con el coste de las
operaciones elementales
Ahora vemos que no es cierto que suma
sea mejor que producto Al menos no
siempre. De
hecho, en diferentes tramos resultan
ganadores diferentes programas:
a) suma mejor que incremento e incremento mejor que producto.
b) suma mejor que producto y producto mejor que incremento
c) producto mejor que suma y suma mejor que incremento.
Fjarse en que a partir de n = 13, siempre resulta mejor producto.
Dependencia del tiempo con el coste de las
operaciones elementales
Aunque el producto sea mucho ms caro del que hemos supuesto, siempre habr un valor de n a
partir del cual producto es el programa ms rpido: su curva es plana, no crece, mientras que
las otras dos crecen (una ms rpidamente que la otra, pero ambas crecen) as que siempre habr un
valor de n a partir del cual producto sea ms rpido.
Pongamos que el producto es casi el doble de caro, que cuesta, digamos, 600 s:
Dependencia del tiempo con el coste de las
operaciones elementales
Podemos decir algo similar al comparar suma con incremento: no importa cuan costosa sea la
operacin de suma, siempre habr un valor de n a partir del cual suma es mejor que incremento.
O sea, independientemente del coste de cada operacin bsica, producto siempre acaba siendo
mejor que los otros dos programas.

Un algoritmo que tarda un tiempo constante siempre acaba siendo mejor que uno cuyo tiempo
depende linealmente del tamao del problema. Y un algoritmo cuyo tiempo depende
linealmente del tamao del problema, siempre llega un punto para el que es mejor que otro
algoritmo cuyo tiempo de ejecucin crece cuadrticamente con el tamao del problema.
Decimos que el primer algoritmo es asintticamente ms eficiente que los otros, y que el
segundo algoritmo es asintticamente ms eficiente que el tercero.
Dependencia del tiempo con el coste de las
operaciones elementales
CONCLUSION
Una conclusin es, pues, que si queremos ver cmo evoluciona el coste con el tamao,
podemos hacer estudios asintticos independientes del coste de cada operacin.
Pero el coste asinttico slo nos dice qu programa es mejor cuando el problema es
suficientemente grande por estas razones:
Los programas son especialmente tiles para resolver problemas de gran tamao.
El estudio de costes asintticos nos permite efectuar ciertas simplificaciones en los anlisis
que facilitan enormemente la comparacin de algoritmos.
La primera de dichas simplificaciones, que acabamos de justificar, es que no nos importa la
velocidad con que se ejecuta cada operacin elemental.
Independencia del coste de cada operacin elemental:
el concepto de paso
No nos interesa que nuestros estudios dependan del coste concreto de cada operacin
elemental.
Bastar con que sepamos cuntas operaciones elementales ejecuta un programa y cmo
depende ese nmero del tamao del problema a resolver.

Y qu ser para nosotros una operacin elemental, ahora que nos da igual lo que tarda
cada operacin?

Responder a esta pregunta nos lleva a introducir el concepto de paso. Un paso es un
segmento de cdigo cuyo tiempo de proceso no depende del tamao del
problema considerado y est acotado por alguna constante. Una suma es una operacin
elemental, y un producto, y un incremento. . . Calcular la longitud de una cadena no es una
operacin elemental.

Por qu? Porque cuesta tanto ms cuanto ms larga es la cadena
Independencia del coste de cada operacin elemental:
el concepto de paso
Aqu tenemos algunas operaciones que siempre consideramos pasos:
operaciones aritmticas,
operaciones lgicas,
comparaciones entre escalares,
accesos a variables escalares,
accesos a elementos de vectores o matrices,
asignaciones de valores a escalares,
asignaciones de valores a elementos de vectores o matrices,
lectura de un valor escalar,
escritura de un valor escalar,
Independencia del coste de cada operacin elemental:
el concepto de paso
Definimos el coste computacional temporal de un programa como el nmero de pasos expresado
en funcin de la talla del problema.
Contemos los pasos de cada programa
Inicio
Leer n
m n*n
Escribir m
Fin

2 pasos
Producto
El nmero total de pasos es 2.
Independencia del coste de cada operacin elemental:
el concepto de paso
Inicio
Leer n
m 0
para(i0; i<n; i++)
mm+10
Escribir m
Fin
Suma
1 paso
2 pasos n veces
2n+2 pasos
O sea, un total de : 1+2n+2+2n = 4n+3 pasos.
Independencia del coste de cada operacin elemental:
el concepto de paso
Inicio
Leer n
m 0
para(i0; i<n; i++)
para(j0; j<n; j++)
m++;
Escribir m
Fin
1 paso
2n+2 pasos
2n + 2 pasos n veces
1 paso n
2
veces
Sumando tenemos un coste de: 1+2n+2+n(2n+2)+n
2
= 3n
2
+4n+ 3 pasos.
Independencia del coste de cada operacin
elemental: el concepto de paso
En resumen:
El valor concreto de los factores de cada trmino en estas expresiones del nmero de pasos
no importa.
Con la introduccin del concepto de paso da igual decir que el coste de un algoritmo es
2n+3 que c1 n + c2, siendo c1 y c2 constantes arbitrarias.
Cualquier secuencia de pasos cuya longitud no depende del tamao del problema cuenta
como una cantidad constante de pasos.
Esta nueva simplificacin ayuda enormemente a efectuar conteos de pasos. Podemos
reescribir la tabla anterior as
Independencia del coste de cada operacin elemental:
el concepto de paso
Ejemplos:
Inicio (n)
s 0
para (i 1; i <n; i++)
s s + i
Fin
Inicio (n)
s 0
i 1
mientras (i <=n) hacer
inicio
s s + i
i i + 1
fin
Fin
Calcula el sumatorio de los n primeros nmeros enteros
Mejor Caso, Peor Caso, Caso Promedio
Tamao (talla) e Instancia
Algunos de los ejemplos que hemos estudiado hasta el momento confunden los
conceptos de tamao e instancia porque en ellos coinciden ambos. Por ejemplo, al
calcular n
2
la talla o tamao era el mismo valor n, que describe a la vez el problema
concreto a resolver, es decir, determina la instancia a resolver. Cuando calculbamos
el valor del sumatorio de los n primeros nmeros, la instancia vena determinada por
n, al igual que el tamao. Pero hay problemas en los que, para una misma talla, hay
muchas instancias diferentes. Por ejemplo, al ordenar un vector de enteros podemos
distinguir claramente tamao e instancia: no hay un nico vector de talla 10. Cada
vector diferente de talla 10 es una instancia diferente del problema de ordenacin.
Consideremos algunos ejemplos ms.
Mejor Caso, Peor Caso, Caso Promedio
Sumatorio(a,b)
Inicio
i a
s 0
mientras(i <= b)hacer
Inicio
s i
i++
Fin
return s
fin

Funcin que calcula la suma de todos los enteros
Comprendidos entre a y b (incluidos ellos)siendo
a <= b
1 paso
1 paso
(b-a+1)+1= n+1 pasos
1 paso n veces
1 paso n veces
t(n)= 3n+3
Mejor Caso, Peor Caso, Caso Promedio
Funcin que calcula la suma de todos los enteros
Comprendidos entre a y b (incluidos ellos)siendo
a <= b
Sumatorio(a,b)
Inicio
i a
s 0
mientras(i <= b)hacer
Inicio
s i
i++
Fin
return s
fin

La instancia viene determinada por los valores
concretos de a y b, pero la talla esta relacionada
con n = b a + 1: cuanto mayor es la diferencia
entre b y a, ms grande es el problema. El coste
temporal es funcin de n:

t(n)=c
1
n+c
2

Por ejemplo:
si a=1 y b=10 (instancia)
n=10-1+1=10 (tamao o talla)
si a=51 y b=60 (instancia)
n=60-51+1=10 (tamao o talla)
Para un valor dado de la talla n hay una infinidad de valores posibles de a y b, es decir, de
instancias
posibles
Mejor Caso, Peor Caso, Caso Promedio
Analicemos otro algoritmo:
Un algoritmo que calcula el sumatorio de nmeros de un vector.
SumaVector(A,n)
Inicio
s 0;
para(i0; i<=n-1;i++)
ss+A[i];
Fin
1 paso
2n+2 pasos
2 pasos n veces
T(n)= 4n +3
Antes de empezar el anlisis hemos de tener claro qu parmetro determina el tamao
del problema.
Ahora no tenemos uno o dos valores escalares como datos, sino una lista o vector. En este
caso, la
talla del problema es la longitud del vector. A ms elementos en el vector, ms grande
es el problema
y ms cuesta calcular el sumatorio.
Mejor Caso, Peor Caso, Caso Promedio
Para un valor dado de n hay una infinidad de listas diferentes. Por ejemplo, [1, 3, 5],
[-4, 2, 109]
y [0, 0, 2] son tres instancias de talla n = 3.
Hemos visto, de momento, que el coste depende de la talla del problema, y no de la
instancia.
No siempre es as.
Coste dependiente de la instancia
Mejor Caso, Peor Caso, Caso Promedio
Vamos a analizar otro programa: una funcin que recibe un vector de nmeros
diferentes y un elemento buscado y dice si el elemento pertenece o no al vector
bool pertenece(A,n,buscado)
Inicio
encontrado falso
i0
mientras(i<=n-1) and (no encontrado) hacer
inicio
si (buscado= A[i])
entonces
encontrado verdadero
i++
fin
Fin
1 paso
1 paso
Entre 2 y n+1 pasos
Entre 1 y n pasos
Entre 0 y 1 paso
Entre 1 y n pasos
Este anlisis es ms complicado que los realizados hasta el momento. Una lnea supone la ejecucin de un nmero
indeterminado de pasos, hay una sentencia que se ejecuta entre una y n veces y otra
que se ejecuta a lo sumo una vez!
Mejor Caso, Peor Caso, Caso Promedio
Sigamos una aproximacin emprica. Ejecutemos el programa con diferentes tallas y
diferentes
instancias para cada talla o tamao y veamos cuntos pasos cuesta en cada caso.
Esta grfica muestra, en funcin de n, el nmero de pasos para diferentes instancias
del problema:
Mejor Caso, Peor Caso, Caso Promedio
No obtenemos, como hasta ahora, una curva, sino una serie de puntos con una gran
variabilidad.
Cada vez que ejecutamos el programa con una instancia diferente tarda un nmero
de pasos diferente, incluso para un valor de n fijo Cmo podemos caracterizar este
comportamiento?







Centrmonos en las dos situaciones extremas del algoritmo, en su comportamiento
para una
situacin ideal y en su comportamiento para la peor situacin imaginable:
analicemos el mejor y el peor de los casos.
El mejor Caso
Cuando hablamos del mejor de los casos nos referimos a las
instancias que, para cada valor particular de n, se resuelven
ms rpidamente con el algoritmo estudiado
En nuestro caso, esa instancia es siempre aquella en la que el
elemento buscado ocupa la primera posicin del vector.


Mejor Caso, Peor Caso, Caso Promedio
Por ejemplo:
Si el vector es A=[8,2,5,9,1] , n=5, buscado=8


El Peor Caso
El peor de los casos lo determinan aquellas instancias
que, para cada valor de n, hacen que el algoritmo se
ejecute con el mayor nmero posible de pasos. En
nuestro programa, el peor caso es aqul en el que el
elemento buscado no est en la lista, pues entonces
hemos de recorrerla completamente
Mejor Caso, Peor Caso, Caso Promedio
Por ejemplo:
Si A=[5,3,7,2,4], n = 5 y buscado=9
Mejor Caso, Peor Caso, Caso Promedio
bool pertenece(A,n,buscado)
Inicio
encontrado falso
i0
mientras(i<=n-1) and (no encontrado) hacer
inicio
si (buscado= A[i])
entonces
encontrado verdadero
i++
fin
Fin
1 paso
1 paso
Entre 2 y n+1 pasos
Entre 1 y n pasos
Entre 0 y 1 paso
Entre 1 y n pasos
En el mejor de los casos (el elemento buscado es el primero de la lista) el algoritmo ejecuta un
nmero constante de pasos no importa cun grande sea el vector, entonces el coste no
depende de n y es una simple constante, es decir:
t(n)= 7
o mejor t(n)= C
0


Mejor Caso, Peor Caso, Caso Promedio
t(n)= 7
t(n)= C
0


bool pertenece(A,n,buscado)
Inicio
encontrado falso
i0
mientras(i<=n-1) and (no encontrado) hacer
inicio
si (buscado= A[i])
entonces
encontrado verdadero
i++
fin
Fin
1 paso
1 paso
Entre 2 y n+1 pasos
Entre 1 y n pasos
Entre 0 y 1 paso
Entre 1 y n pasos
Mejor Caso, Peor Caso, Caso Promedio
En el peor caso (el elemento buscado no esta en la lista)
el nmero de pasos que ejecuta el algoritmo si depende de n. El coste para el peor
caso ser:
t(n)= 3n+3
t(n)= C
0
n+C
1

Mejor Caso, Peor Caso, Caso Promedio
t(n)= 3n+3
t(n)= C
0
n+C
1

Es decir, el coste cuando el elemento no existe son puntos encima de la
lnea
Mejor Caso, Peor Caso, Caso Promedio
En conclusin, el tiempo invertido para resolver cada
Instancia esta acotado inferiormente por una curva de
La forma t(n)= C
0
y acotado superiormente por una
curva de la forma t(n)= C
0
n+C
1

Caso Promedio.
Promediando el nmero de pasos de la ejecucin de toda
instancia para cada valor de n, tendramos una nueva curva
en la grfica con su propio comportamiento asinttico.
Mejor Caso, Peor Caso, Caso Promedio
Lo nico que sabemos a ciencia cierta sobre la curva
De coste promedio es que siempre est comprendida
Entre las otras dos curvas
Cul es el coste ms interesante?
Nosotros centraremos la atencin en el anlisis del coste en el peor y el mejor
de los casos por las siguientes razones:
Por el momento, las herramientas matemticas a nuestro alcance hacen
relativamente sencillo el anlisis de estos costes. El coste promedio es,
normalmente, mucho ms complicado de estimar y requiere destreza con
ciertas tcnicas matemticas avanzadas.
Un estudio apropiado del coste promedio implica efectuar asunciones
acerca de la distribucin estadstica de las instancias, lo cual no siempre
resulta inmediato.
A fin de cuentas, el coste promedio siempre est acotado superiormente
por el coste en el peor de los casos e inferiormente por el coste en el
mejor de los casos. Estimar, pues, estos ltimos costes proporciona
implcitamente cierta informacin sobre el coste en el caso promedio. En
no pocas ocasiones, cuando el mejor y el peor de los casos coinciden,
conocemos implcitamente el coste en el caso promedio.
Notacin asinttica
Son herramientas matemticas fundamentales que
simplifican notablemente los anlisis de costes y
permiten expresar de forma muy concisa los
resultados.

Aprenderemos a caracterizar el coste mediante
funciones simples que acoten superior e
inferiormente el coste de toda instancia para
tamaos suficientemente grandes. Para ello
necesitamos definir familias de cotas.
O grande, orden
Sea f : N R
+
una funcin de los naturales en los
reales positivos. Definimos la siguientes familia de
funciones:
O(f(n)), se lee orden de f(n), es el conjunto
de funciones cuyo valor es siempre menor que un cierto
nmero constante c de veces f(n) para valores de n
suficientemente grandes. Es decir, es el conjunto de funciones
que, asintticamente, podemos acotar superiormente con una
funcin proporcional a f(n).
Este grfico ilustra qu significa que una funcin t(n) sea O(f(n)):

O grande, orden
Hay un punto, un valor de n al que denominamos n
0
, a partir del cual es seguro que
t(n) es menor que cf(n) para algn valor constante de c, aunque en el tramo inicial
t(n) pueda ser mayor que cf(n).
La funcin t(n) = n+1, por ejemplo, pertenece a O(n), pues siempre hay un valor n
0
y
un valor c para los que cn >= n+1 si n=n
0
. Considera, por ejemplo, n
0
= 1 y c = 10. La
expresin t(n)O(f(n)) se lee tanto ((t(n) pertenece a O(f(n)) como t(n) es O(f(n)).
O grande, orden
Ejemplo.
Considere la funcin t(n) = 2n + 10, y suponga
que se quiere mostrar que t(n) O(n).
Segn la definicin, se debe encontrar una
constante real positiva c y un nmero natural
n
0
tales que para todo nmero natural n n
0

se verifique que t(n) f(n); es decir

t(n) c* n

O grande, orden
2n+10 cn
(c-2) n 10
n 10 / (c-2)
Haciendo que c = 3
tenemos que n
0
= 10
As que para c= 3 y
n
0
= 10 se verifica que
t(n) O(n)


1
10
100
1,000
10,000
1 10 100 1,000
n
3n
2n+10
n
O grande, orden
Ejemplo:
5n
3
+ 3n
2
+1 O(n
3
)

tomando n
0
= 2, c= 7 tenemos que:
5n
3
+ 3n
2
+1 6n
3


Nota: Tambin pertenecera a O(n
4
), pero no a O(n
2
).
O grande, orden
Considere la funcin t(n) = 8n + 128, y suponga que se
quiere mostrar que t(n) O(n
2
). Segn la definicin, se
debe encontrar una constante real positiva c y un nmero
natural n
0
tales que para todo nmero natural n n
0
se
verifique que t(n) cn
2
.
Suponga que se selecciona c = 1. Se tiene entonces que:
t(n) c n
2
, 8n + 128 n
2

0 n
2
8n 128 0 (n 16) (n + 8)
Como n+8 > 0, se concluye que n16 0.
Por lo tanto, n
0
= 16.
As que, para c = 1 y n
0
= 16, t(n) cn
2
.
Luego, t(n) O(n
2
).

O grande, orden
Omega ()
Sea f : N R
+
una funcin de los naturales en los reales
positivos. Definimos la siguiente familia de funciones
Cuando una funcin t(n) es (f(n)) (decimos que pertenece a
omega de f(n) o que es omega de f(n)) est acotada
inferiormente por c f(n) para valores de n suficientemente
grandes y algn valor c, es decir, hay un valor n
0
tal que,
para todo n mayor, la funcin t(n) es mayor que cf(n).
Omega ()
Zeta ()
Cuando una funcin t(n) es a la vez O(f(n)) y
(f(n)), decimos que es (f(n)) (que se lee zeta de f(n)).
Una funcin t(n) que pertenece a (f(n)) est acotada superior e
inferiormente por funciones proporcionales a f(n) a partir de un
valor determinado de n.
Ejemplo 1, la funcin t(n) = 3n + 2 es (n)
porque:
t(n) es menor que 4n para todo n mayor o igual
que 2, as que es O(n);
Por otra parte, t(n) es mayor o igual que 2n
para todo n mayor o igual que 1, as que es
(n).
Zeta ()
Zeta ()
Ejemplo 2. La siguiente funcin es (.) de algn polinomio?
t
2
(n) es O(n
2
) y (n), as que no es () de un polinomio.
EJERCICIOS
EJERCICIOS
Jerarqua de cotas
Jerarqua de cotas
Las funciones que pertenecen a cada orden
tienen un adjetivo que las identifican:
As, decimos que el coste (temporal) de un algoritmo es lineal cuando es
O(n) y cbico cuando es O(n
3
). De hecho, abusando del lenguaje decimos
que el algoritmo es lineal o cbico, respectivamente.
Qu implica, para efectos prcticos, que un coste sea
logartmico, lineal, exponencial, etc.? Lo mejor sera
que comparemos algunas grficas de crecimiento.
Empecemos por los crecimientos lineal y sublineales.
Jerarqua de cotas
Crecimiento sublineal
Un algoritmo de coste constante es independiente de la talla del problema.
Un algoritmo que soluciona un problema en tiempo constante es lo ideal:
a la larga es mejor que cualquier algoritmo de coste no constante.
El coste de un algoritmo logartmico crece muy
lentamente conforme n crece. Por ejemplo, si
resolver un problema de talla n = 10 tarda 1 s,
puede tardar 2 s en resolver un problema 10
veces ms grande (n = 100) y slo 3 s en resolver
uno 100 veces mayor (n = 1000).
Un algoritmo cuyo coste es crece a un ritmo
superior que otro que es (log n), pero no llega a
presentar un crecimiento lineal. Cuando la talla se
multiplica por cuatro, el coste se multiplica por dos.
Crecimiento sublineal
Crecimiento superlineal
Un algoritmo O(n log n) presenta un crecimiento
del coste ligeramente superior al de un algoritmo
lineal. Por ejemplo, si tardamos 10s en resolver
un problema de talla 1000, puede que tardemos
22 s, poco ms del doble, en resolver un
problema de talla 2000.
Un algoritmo cuadrtico empieza a dejar de ser
til para tallas medias o grandes, pues pasar a
tratar con un problema el doble de grande
requiere cuatro veces ms tiempo.
Crecimiento superlineal
Un algoritmo cbico slo es til para
problemas pequeos: duplicar el tamao del
problema hace que se tarde ocho veces ms
tiempo.
Un algoritmo exponencial raramente es til. Si
resolver un problema de talla 10 requiere una
cantidad de tiempo determinada con un
algoritmo O(2
n
), tratar con uno de talla 20
requiere unas 1000 veces ms tiempo!
Crecimiento superlineal
Tasas de crecimiento
Si las instancias de un problema de talla n = 1 se resuelven con varios algoritmos
constantes, lineales, etc. en 1 s. Esta tabla muestra el tiempo aproximado que cuesta
resolver problemas con
cada uno de ellos:
Tener en cuenta que un en son mil millones de aos y que los cientficos estiman
actualmente que la edad del universo es de entre 13 y 14 eones.
Tasas de crecimiento
Propiedades de las cotas
Propiedades de las cotas
Propiedades de las cotas
Conceptos matemticos bsicos
Exponentes
Conceptos matemticos bsicos
Logaritmos.
Conceptos matemticos bsicos
SERIES.
ANALISIS DE ALGORITMOS
ITERATIVOS
Para evaluar la complejidad de un algoritmo iterativo es
necesario evaluar la complejidad de las operaciones que
lo conforman

1. Complejidad de operaciones y asignaciones simples
Las instrucciones de asignacin, los accesos a elementos
de un vector y las expresiones aritmticas y lgicas,
(siempre que no involucren variables cuyos tamaos
dependan del tamao del problema) tendrn un coste
constante, O(1).
No se cuentan los return.
2.- Costo de una secuencia de instrucciones
Para calcular el coste de una composicin
secuencial de instrucciones: S1; S2
Se suma los costes de S1 y S2. Si el coste de S1
est en (f1(n)) y el de S2 est en (f2(n)),
Entonces: (f1(n)) + (f2(n)) = (max(f1(n), f2(n))).
8/09/13
ANALISIS DE ALGORITMOS
ITERATIVOS
Ejemplo 1
Inicio
a 1
a a+1
z b*4
Fin
8/09/13
O(1)
O(1)
O(1)
T(n) = 3O(1) = O(1)
ANALISIS DE ALGORITMOS
ITERATIVOS
Ejemplo 2.
Inicio
Leer Nota1
Leer Nota2
Promedio (Nota1+Nota2)/2
Escribir Promedio
Fin
ANALISIS DE ALGORITMOS
ITERATIVOS
T(n) = O(1)
3. Coste de una instruccin
selectiva:
Para calcular el coste de una
instruccin condicional:
si (B)
entonces
{S1}
caso contrario
{S2}
8/09/13
ANALISIS DE ALGORITMOS
ITERATIVOS
Si el coste de S1 es O(f1(n)), el
de S2 es O(f2(n)) y el de B es
O(fB(n)),
Entonces:

O(max(fB(n), f1(n), f2(n)).
Ejemplo 3
Inicio
Leer N
Si (N mod 2)=0
Entonces
Escribir N
Caso Contrario
Inicio
suma 0
para (i 1 ; i N; i++)
suma suma +i
Fin
Fin
ANALISIS DE ALGORITMOS
ITERATIVOS
O(1)
O(n)
T(n) = max (O(1), O(n)= O(n)
ANALISIS DE ALGORITMOS
ITERATIVOS
ANALISIS DE ALGORITMOS
ITERATIVOS
8/09/13
ANALISIS DE ALGORITMOS
ITERATIVOS
t(n) = n(m-2)C
1
O(nm)
Ciclos anidados dependientes
para (i1; i n; i++)
para (j i; j n; j++)
{instrucciones de costo c}

ANALISIS DE ALGORITMOS
ITERATIVOS
O(n
2
)
Ejemplo 4.
Inicio
Leer n
mientras (n >= 1)
Inicio
escribir n
n n /2
Fin
Fin
ANALISIS DE ALGORITMOS
ITERATIVOS
Iteraciones

1 n/2
2 n/4
3 n/8
4 n/16
.
.
K n/2
k
El n de iteraciones es tal que:
n/2
k
< 1

Entonces n=2
k


k = log n

Por lo que t(n) = O(log n)
Ejemplo 5.
Inicio
c 1
mientras (c < n) hacer
Inicio
escribir c
c 2* c
Fin
Fin

ANALISIS DE ALGORITMOS
ITERATIVOS
Iteraciones

1 2 x 1 = 2 = 2
1
2 2 x 2 = 4 = 2
2
3 2 x 4 = 8 = 2
3
4 2 x 8 = 16 = 2
4

.
.

. .
K 2
k
El numero de iteraciones es tal que:

(2
k
n) por lo que k = log n

Entonces t(n) es O(log n)

Ejemplo 6
Inicio
para (i 1; i n; i++ )
Inicio
c i
mientras (c > 0 ) hacer
Inicio
{instrucciones}
c c/2
fin
Fin
Fin
ANALISIS DE ALGORITMOS
ITERATIVOS
O(log n)
O(n log n)