Anlisis de Algoritmos

Complejidad de los algoritmos

Complejidad espacial: cantidad de memoria que
consume
Complejidad temporal: tiempo que requiere para
resolver un problema

Complejidad temporal (emprico)

Mediremos el tiempo de ejecucin con varios programas
que resuelven el mismo problema: la ordenacin de un
vector de enteros
El tiempo de ejecucin depender del tamao del vector
a ordenar, el estudio considera la dependencia del
tiempo en funcin del tamao.

Algoritmo de obtencin del dato

mas grande

(Haga un programa que genere aleatoriamente 1000 numeros enteros entre 0 y 100 000.)

(Usar la funcion clock() para determinar el tiempo que tarda el programa en resolver la ordenacin de los datos.)

Programa de obtencion del dato mas grande:

#include <iostream>

int main()

int datos[100],d,i,temp,j,a;

cout << "\n\nIngresa los numeros de datos a guardar: ";

cin >> d;

for(i=1;i<=d;i++)

cout << "\nIngresa el dato " << i << " : ";

}

cin >> datos[i];

Algoritmo de ordenacin de un
vector
for(a=1;a<1000;a++)
{

for (i=1; i<=d; i++)

for (j=1; j<d; j++)

if(datos[j]>datos[j+1])

temp=datos[j];

datos[j]=datos[j+1];

datos[j+1]=temp;

cout << "\nEl dato mayor es: " << datos[d];

}

return 0;
}

Anlisis de resultados
medidas obtenidas tras 10 ejecuciones:
0.66 0.69 0.69 0.70 0.67 0.70 0.70 0.68 0.69
0.68
La estadstica descriptiva proporciona informacin
acerca del tiempo de ejecucin.
La media del tiempo de ejecucin es de 0.686 segundos
La desviacin estndar, 0.0135.
Y si el vector de datos es mas pequeo o mas grande?

Comparacin entre lenguajes

Es mejor un algoritmo si este se programa en un
determinado lenguaje?

Complejidad temporal:
aproximacin terica
Producto.c
1 #include <stdio.h>
2
3 int main(void )
4 {
5 int m;
6
7 m = 10 * 10;
8 printf("%d\n ", m);
9 return 0;
10 }

Complejidad temporal:
aproximacin terica
Suma.c
1 #include <stdio.h>
2 int main(void )
3{
4 int m, i;
5
6 m = 0;
7 for (i=0; i<10; i++)
8
m = m + 10;
9 printf("%d\n ", m);
10 return 0;
11 }

Complejidad temporal:
aproximacin terica
incremento.c
1#include <stdio.h>
2
3 int main(void )
4{
5 int m, i, j;
6
7 m = 0;
8 for (i=0; i<10; i++)
9 for (j=0; j<10; j++)
10 m++;
11 printf("%d\n ", m);
12 return 0;
13 }

Complejidad temporal:
aproximacin terica
Operacin: Producto Suma Incremento Asignacin Comparacin
Tiempo:
342 s
31 s
1s
1s
Aplicando para cada caso:
Programa
Productos Sumas Incrementos Asignaciones

1s

Comparaciones Tiempo

producto.c

1
343 s

suma.c
343 s
incremento.c
121
343 s

1
10

10
210

12

11
12

Complejidad temporal:
aproximacin terica
No es tan fcil, pues, decidir que programa es ms rpido, al menos no si queremos
tener en cuenta el coste de cada instruccin ya que ste depende del ordenador.
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 n2, siendo n un entero cualquiera: producto.c
#include <stdio.h>
int main(void ){
int m, n;
scanf("%d ", &n);
m = n * n; 1 suma y 1 asignacin
printf("%d\n ", m);
return 0;
}

Algoritmo: n X n
suma.c

#include <stdio.h>
int main(void )
{
int m, n, i;
scanf("%d ", &n);
m = 0;
for (i=0; i<n; i++)
m = m + n;
printf("%d\n ", m);
return 0;
}

incremento.c

Algoritmo: n X n
suma.c

incremento.c

#include <stdio.h>
int main(void )
{
int m, n, i;
scanf("%d ", &n);
m = 0;

//1 asignacin

for (i=0; i<n; i++) //1 asignacin, n + 1 comparaciones y n incrementos

m = m + n;

//

1 suma y 1 asignacin

printf("%d\n ", m);

return 0;
}

Evolucin del costo temporal en funcin del

numero de datos

Evolucin del costo temporal en funcin del

numero de datos
Operacin Producto Suma Incremento Asignacin Comparacin
Tiempo
100 s
5s
1s
1s
1s

Evolucin del costo temporal en funcin del

numero de datos
Operacin Producto Suma Incremento Asignacin Comparacin
Tiempo
100 s
5s
1s
1s
1s

Independencia del costo de cada operacin

elemental: el concepto de paso
Un paso es un segmento de cdigo cuyo tiempo de proceso no depende de la talla del
problema considerado y est acotado por alguna constante.
Una suma, un producto, un incremento son operaciones elementales.
Calcular la longitud de una cadena no es una operacin elemental, porque cuesta ms
cuanto ms larga es la cadena.
Operaciones elementales:

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,

Pasos en cada programa:

producto.c

1
2
3
4
5
6
7
8
9

#include <stdio.h>
int main(void )
{
int m, n;
scanf(" %d ", &n);
m = n * n; 1 paso
printf(" %d\n ", m);
return 0;
}

Total de pasos: 1

suma.c

1 #include <stdio.h>
2 int main(void )
3{
4 int m, n, i;
5 scanf(" %d ", &n);
6 m = 0;
1 paso
7 for (i=0; i<n; i++)
2n + 2 pasos
8 m = m + n; 2 pasos, n veces
9 printf(" %d\n ", m);
10 return 0;
11 }
Total de pasos: 4n + 3

Pasos en cada programa:

incremento.c

1 #include <stdio.h>
2 int main(void )
3{
4 int m, n, i, j;
5 scanf(" %d ", &n);
6 m = 0; 1 paso
7 for (i=0; i<n; i++) 2n + 2 pasos
8 for (j=0; j<n; j++) 2n + 2 pasos, n veces
9 m++;
1 paso, n2 veces
10 printf(" %d\n ", m);
11 return 0;
12 }

Total de pasos:

2n2 + 4n + 4 pasos.

Resumiendo:

Resumiendo:
Programa
Productos Sumas Incrementos Asignaciones Comparaciones
producto.c
1
1
suma.c
n
n
n+2
n+1
incremento.c
2n2 +n
n+ 2
n2 + 2n + 1
En el supuesto de que un
producto tarde 342 s, una
suma 31s y 1s el resto de
operaciones, la evolucin del
costo con el numero de datos se
puede representar grficamente
as:

Simplificaciones:
Cualquier secuencia de pasos cuya longitud no depende de la talla del
problema cuenta como una cantidad constante de pasos.
El valor concreto de los factores de cada trmino en las expresiones del nmero
de pasos no importa. Podramos haber decidido que, en nuestro ordenador, la
sentencia s += n cuente como dos pasos (suma por un lado y asignacin por
otro) o como uno (suma y asignacin).
O sea, con la introduccin del concepto de paso da igual decir que el costo de
un algoritmo es:
2n+3 que c1 n + c2, siendo c1 y c2 constantes arbitrarias.
Podemos reescribir la tabla anterior as:
programa
producto.c suma.c
incremento.c
pasos
c0 c1 n + c2 c3 n2 + c4 n + c5

Independencia del lenguaje de programacin y de

los detalles de implementacin
sumatoria1.c

int sumatoria(int n)
{
int s, i;
s = 0;
for (i=1; i<=n; i++)
s = s + i;
return s;
}

1
2
3
4
5
6
7
8

int sumatoria(int n)
{
int s, i;
s = 0;
1 paso
for (i=1; i<=n; i++)
2n + 2 pasos
s = s + i;
2 pasos, n veces
return s;
1 paso
}

El total es de 4n + 4 pasos, pero se simplifica con la expresin:

c0 n + c1.

Segunda versin para el clculo de la sumatoria

sumatoria2.c

1 int sumatorio(int n)
2{
3 int s, i;
4 s = 0;
1 paso
5 i = 1; 1 paso
6 while (i<=n) {
1 paso, n + 1 veces
7 s = s + i;
1 paso, n veces
8 i = i + 1;
1 paso, n veces
9}
10 return s;
1 paso
11 }

Un total de 3n+4 pasos, o sea, c2 n+c3 pasos

Sumatoria en Python
sumatorio.py
1 def sumatorio(n):
2 s = 0 1 paso
3 for i in range(1, n+1):
2n pasos
4 s = s + i 1 paso, n veces
5 return s 1 paso
El coste total del programa Python tambin puede expresarse, pues, como c4 n + c5 pasos:

Programa

sumatorio1.c c0 n + c1

sumatorio2.c c2 n + c3

sumatorio.py c4 n + c5

Costo

En los tres programas, en proporcin directa al tamao de datos del problema

Mejor caso, peor caso, caso promedio

1 def pertenece(lista, buscado):
2 for elemento in lista: entre 1 y n pasos
3
if elemento == buscado:
1 paso, entre 1 y n veces
4
return 1 1 paso, entre 0 y 1 veces
5 return 0

1 paso

Cuntos pasos en funcin de n, se ejecutan?

Hay veces que muy pocos (cuando el elemento buscado ocupa las
primeras posiciones de lista) y hay veces que muchos (cuando el
elemento buscado est hacia el final de lista o, sencillamente, no est
en lista).

Mejor caso, peor caso, caso promedio

En el mejor de los casos, la
funcin ejecuta un nmero
constante de pasos (tres).
Si el elemento buscado
est en la primera posicin
de la lista, la funcin
finaliza enseguida: se
asigna a i el valor del
primer elemento, se
compara i con buscado y
ambos valores coinciden, y
se devuelve el valor 1.
En el mejor de los casos,
pues, el coste no depende
de n y es una simple
constante c0.

Mejor caso, peor caso, caso promedio

El coste en el peor de los casos (el elemento buscado no est en
la lista) s depende de n: se asigna a i el valor de cada uno de los
n elementos, se compara i con buscado n veces sin que coincida
ninguna de las veces,
se devuelve el valor 0 desde el return que hay fuera del bucle.
El costo total para el peor caso es de c1 n+c2 pasos.
El costo de resolucin de cada instancia est siempre por debajo
del que determina una lnea recta:

Notacin asinttica
Orden y omega
Sea
una funcin de los naturales en los reales
positivos. Definimos las siguientes familias de
funciones:

Orden de n: O(n)
Hay un punto, un valor de n al que denominamos n0, a
partir del cual es seguro que t(n) es menor que cf(n) para
algn valor constante de cf(n) 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 n0 y un valor c para los que cn >=
n+1 si n >= n0. Considera, por ejemplo, n0 = 1 y c = 10.
La expresin t(n) O(f(n)) se lee:
t(n) pertenece a O(n) o
t(n) es O(n).

Ejemplos
Pertenece t(n) = 3n + 2 a O(n)?
La respuesta es s. Para todo n mayor o igual que 2, t(n) es
menor que cn cuando c es, por ejemplo, 4:
t(n) = 3n + 2 <= 4n,

para todo n >= 2. t(n) que pertenece a O(n).

Pertenece t(n) = 100n + 6 a O(n)?

S:
t(n) = 100n + 6 <= 101n, para todo n >= 6 t(n) que
pertenece a O(n).
Pertenece t(n) = 10n2 + 4n + 2 a O(n2)?
S:
t(n) = 10n2 + 4n + 2 <= n2, para todo n >= 5 t(n) que
pertenece a O(n2)

Ejemplos
Pertenece t(n) = 10n2 + 4n + 2 a O(n)?
No. No existen valores de c y n 0 tales que t(n) <= cn para todo n mayor o igual
que n0.
Pertenece t(n) = 6 2n + n2 a O(2n)?
S:
t(n) = 6 2n + n2 <= 72n, para todo n >= 4 t(n) que pertenece a O(2n)

Pertenece t(n) = 6 2n + n2 a O(n100)?

No. No existen valores de c y n 0 tales que t(n) <= cn100 para todo n mayor o igual
que n0.
Pertenece t(n) = 3 a O(1)?
S.
t(n) = 3 <= 3, para todo n >= 0

t(n) que pertenece a O(1)

Omega de n
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 cf(n) para valores de n suficientemente
grandes y algn valor c, es decir, hay un valor n0 tal que, para
todo n mayor, la funcin t(n) es mayor que cf(n).

Ejemplo:
pertenece t(n) = 10n2 + 4n + 2 a
(n2)?
La respuesta es s. Para n >= 5, el
valor de t(n) es siempre menor que
11n2.

Zeta de f(n)
Cuando una funcin t(n)
es a la vez O(f(n)) y
(f(n)), decimos que es
(f(n)) (se lee zeta de f(n)).

(f(n)) = O(f(n))
(f(n)).
Una funcin t(n) que
pertenece a (f(n)) est
acotada superior e
inferiormente por sendas
funciones proporcionales
a f(n) a partir de un valor
determinado de n:

Ejemplo:
Por ejemplo, la funcin t1(n) = 3n + 2 es (n): 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
uno, as que es (n).
Esta otra funcin, sin embargo, no es O() y () de un algn polinomio o
funcin simple:

t2(n) =

n2 si n es par;
n si n es impar.

t2(n) es O(n2) y (n), as que no es () de de un polinomio.

Ejercicios 1:
a.
b.
c.
d.
e.
f.
g.

Determina el orden y omega de las siguientes

funciones:
t(n) = n + 3.
t(n) = 2n2 + 1000
t(n) = 8n2 + n
t(n) = 0.1n2 + 10n + 1
t(n) = n6 + n3 + 10n
t(n) = n100 + n99
t(n) = 2n + n100

Ejercicios 2:
Determina el orden/omega (y zeta si procede) de las
siguientes funciones:
a. t(n) = 4.
b. t(n) = n2 + n
c. t(n) = 20n3 n2 + 1000n
d. t(n) = n log(n)
e. t(n) = n log(n3)
f. t(n) = n2 + n log10(n)
g. t(n) =

3n +2 si n es par
8n + n si n es impar

Jerarqua de cotas
Hay una relacin de inclusin entre diferentes rdenes:
O(1) o(log n)