Anlisis y Complejidad

de Algoritmos
Objetivo:
Se introducen los conceptos de
complejidad de algoritmos y se exponen las
ms usuales metodologas para calcular
complejidades.
1

Algoritmia
Diseo de mtodos para resolver problemas

Tenemos una descripcin de los datos del problema (entradas,

especificacin del resultado deseado)
Describimos los mtodos para resolver problema algoritmos
Demostramos que los mtodos corresponden al problema

Complejidad de los mtodos

Eficiencia: tiempo de clculo, espacio en memoria ocupada

Realizacin (implementacin)

Organizacin de los datos Seleccin de una estructura

Implementacin
2

Algoritmo
Historia: el termino algoritmo proviene de Al
Khowarizmi, matemtico rabe del IX siglo

El libro de Al Khowarizmi constituye la base de la notacin

decimal moderna.
Al inicio, la palabra algrismo significaba las reglas necesarias
para efectuar clculos aritmticos utilizando la notacin decimal.
El trmino algoritmo aparece en el siglo XVII.

Algoritmo
Definicin:
Conjunto de reglas operativas, su aplicacin
permite resolver un problema dado por medio
de un nmero finito de operaciones.
Especificacin de esquema de clculo en forma
de una secuencia de operaciones elementales
ordenada, finita y precisa.

Algoritmo
Propiedades:
Las entradas: un algoritmo toma valores de entrada en
un conjunto definido.
La salida: es la solucin del problema inicial

Finitud: el algoritmo debe producir la salida deseada en

un nmero finito de pasos, con la entrada que sea.
Eficiencia: cada paso del algoritmo debe ejecutarse en un
tiempo finito y aceptable.
Generalidad: el algoritmo se aplica a todos los problemas
similares de una forma deseada.

Complejidad en tiempo
La mayora de los algoritmos transforman entradas en
una salida.
La complejidad en tiempo de un algoritmo es funcin del
tamao de las entradas
La complejidad mediana es difcil de obtener en general
Ms bien se estudia la complejidad en lo peor de los
casos:

ms fcil de analizar
crucial en muchas aplicaciones: juegos, finanzas, sw crtico..

Hay 2 mtodos para medir la complejidad:

6

Mtodo 1: Anlisis experimental

Implementar el algoritmo en Java
Ejecutar el programa con muchas entradas y de
composicin diferente
Utilizar un mtodo como
System.currentTimeMillis() para obtener una medida
real del tiempo de ejecucin
Dibujar una grfica (tamao, tiempo) de los resultados.
7

Limitacin del mtodo

Se debe implementar el algoritmo
Se requiere calcular la complejidad antes de la implementacin
para ahorrar tiempo y $$$

Los resultados encontrados no son representativos de

todas las entradas
Para comparar 2 algoritmos diferentes del mismo
problema, debemos utilizar el mismo ambiente
(hardware y software)

Mtodo 2: Anlisis Terico

Se hace a partir del pseudocdigo del algoritmo y no de
la implementacin
Describe el tiempo de ejecucin como una funcin de n,
el tamao de la entrada
Toma en consideracin todas las entradas
Independiente del ambiente (SW, HW)

Varias funciones importantes

Funcin constante f (n) = 1
Funcin lineal
f (n) = n
Funcin logartmica f (n) = log (n)
Funcin cuadrtica f (n) = n2
Funcin cbica,
f (n) = n3
Funcin polinomial f (n) = n2 + n + 1
Funcin Factorial f (n) = n!
Funcin exponencial f (n) = 2n
10

11

Un poco de clculo
Calculamos los valores de esta funcin
f(n) = n2 + 100 n + log10 n + 1000
Para

n = 1, 10, 100, 1000, 10 000, 100 000

12

Orden de crecimiento
f(n) = n2 + 100 n + log10 n + 1000

13

Cundo decimos que un algoritmo es bueno?

Armemos esta tabla..... (los tiempos estn dados en segundos y los
algoritmos corren en la misma mquina)

14

La tabla queda as ..
(los tiempos estn dados en segundos salvo cuando
dice otra cosa)

15

Los datos de la tabla anterior corresponden a una mquina

muy vieja (1979).
Qu pasa si tenemos una mquina 1000 veces ms rpida?. Un
milln de veces ms rpida?.
Cul sera el tamao del problema que podemos resolver en una
hora comparado con el problema que podemos resolver ahora?.

16

Cundo diremos entonces que un algoritmo es bueno?.

Cundo un algoritmo es suficientemente eficiente para
ser usado en la prctica?

=============================
POLINOMIAL = bueno
EXPONENCIAL = malo
=============================
17

Qu pasa si tengo complejidades como las

siguientes?:
n80 (polinomio)
1.001n (exponencial)
esto no ocurre en la prctica

18

Anlisis de Algoritmos
Qu es Complejidad?.
Ordenes de Complejidad.
Complejidad de instrucciones bsicas.
Algunos problemas clsicos.
19

Anlisis de Algoritmos
Qu es Complejidad?
Ordenes de Complejidad.
Complejidad de instrucciones bsicas.
Un problema clsico.
20

Complejidad
Cmo se mide la complejidad?
La complejidad est asociada a un
problema o a una solucin del problema?
La complejidad depende de la
implementacin?
21

Complejidad
Qu se entiende por complejidad?
La Complejidad es una medida de la
cantidad que consume un algoritmo de un
recurso determinado.
En general hablamos de Complejidad
Espacial o Complejidad Temporal.

22

Complejidad
Problema: Pregunta sobre un conjunto de
datos.
Solucin:

Mtodo general para resolver

todas las posibles preguntas.

23

Complejidad
Problema: X = { (p(x), r(x)) | x D }.
Conjunto de pares de preguntas respuestas

Solucin: Es una relacin A: P R tal

que para cada pregunta
posible p, (p, A (p)) X.
Para un problema X existen preguntas ms
difciles de resolver o ms grandes que otras.
24

Complejidad
Problema: X = { ((a, k), i) | a=A [0..n-1]
0 i n-1
a [i] = k}.
Solucin:

Algoritmo de Bsqueda Lineal.

BL responde preguntas fciles y preguntas

difciles (de qu depende la dificultad?).
25

Complejidad
Si el recurso es espacio:
Cantidad de memoria requerida para
una ejecucin.
n + 2.
Si el recurso es tiempo:
Cantidad de tiempo requerido para
una ejecucin.
depende!
26

Complejidad en Tiempo
T (algo, d) = tiempo de ejecucin del algoritmo algo
aplicado sobre los datos d
Complejidad en el peor caso:
T
MAX (algo, n) = max {T(algo, d), d de tamao n}
Complejidad en el mejor caso:
T
MIN (algo, n) = min {T(algo, d), d de tamao n}
Complejidad mediana:
T
MED (algo, n) = p(d) T(algo, d)
d

p(d)= probabilidad de tener el caso d

27

Operaciones elementales
Operaciones bsicas efectuadas por el
algoritmo, ejemplo:

Evaluar una expresin

Asignar un valor a una variable
Mandar a llamar a un mtodo
Etc.

Independientes del lenguaje de programacin

utilizado
Consideramos que tienen un tiempo de ejecucin
constante
28

Ejercicio de conteo
Cuntas veces se repite el ciclo?
for (int i = 0; i < 10; i++)
suma = suma + A[i];
for (int i = 0; i < 10; i++)
for (int j = 0; j < 20; j++)
suma = suma + B[i][j];
29

Ejercicio de conteo
Cuntas veces se repite el ciclo?
for (int i = 0; i < n; i++)
suma = suma + A[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
suma = suma + B[i][j];
30

Contar las operaciones bsicas

Fijndonos en el seudocdigo del algoritmo, podemos
determinar el nmero mximo de operaciones
elementales ejecutadas por el algoritmo, como una
funcin del tamao de la entrada
Algo MaxArr (A, n)
max A[0]
for i 1 to n -1 hacer
if (A[i] > max)
max
A[i]
return max

31

Contar las operaciones bsicas

Fijndonos en el seudo cdigo del algoritmo, podemos determinar
el nmero mximo de operaciones elementales ejecutadas por el
algoritmo, como una funcin del tamao de la entrada

Algo MaxArr (A, n)

# operaciones
max A[0]
2
for i 1 to n-1 hacer
2n-1
if (A[i] > max)
2(n-1)
max A[i]
2(n-1)
i++
2(n-1)
return max
Total 8n-5
32

Estimacin del tiempo

El algoritmo MaxArr ejecuta 8n-5 operaciones
elementales en el peor de los casos;
considerando:
a= tiempo de ejecucin mas rpido de una operacin elemental
b= tiempo de ejecucin mas lento de una operacin elemental
Sea T(n) la complejidad en el peor caso de
MaxArr, entonces
a(8n-5) T(n) b(8n-5)
Entonces el tiempo de ejecucin est limitado
por 2 funciones.
33

Complejidad
Bsqueda en un arreglo:
{Pre Q: a=Arr [0..n-1] x=X}
i = 0;
do (i n arr[i]x) i = i+1 od;
{Pos R: (i=n XArr) (0 i <n Arr[i]=X)}
Operacin bsica: Comparacin.
Si X est en la posicin k k +1 comparaciones.
Si X no est en Arr n comparaciones.
34

Complejidad
Bsqueda en un arreglo:
TBLI (n) = n

en el peor caso.

TBLI (n) = n a (n+1)/2

en el caso promedio.

a es la probabilidad que el valor buscado est

en el arreglo
35

Complejidad
Bsqueda en un arreglo:
TBLI (n) = n a(n+1)/2

en el caso promedio.

36

Complejidad
Bsqueda en un arreglo:
TBLI (n) = n a(n+1)/2

en el caso promedio.

Casos interesantes:
X A a = 1 : TBLI (n) = (n+1)/2
a = : TBLI (n) 3n/4
X A a = 0 : TBLI (n) = n

37

Anlisis de Algoritmos
Qu es Complejidad?.
Ordenes de Complejidad.
Complejidad de instrucciones bsicas.
Un problema clsico.
38

Ordenes de Complejidad
Algoritmo 1 : T1(n) = 1000 n
Algoritmo 2 : T2(n) = 200 n log n
Algoritmo 3 : T3(n) = 10 n2
Algoritmo 4 : T4(n) = 2n

2
1

3
9

1
100
39

1000 n

200 n log n

10 n2

2n

40

Ordenes de Complejidad
Establecer la complejidad precisa es difcil.

entonces se estudia el comportamiento

asinttico.

41

Ordenes de Complejidad
g
T

De k en adelante un mltiplo de f es superior a g y

otro mltiplo de f es inferior a g.
42

Anlisis de Algoritmos
Qu es Complejidad?.
Ordenes de Complejidad.
Complejidad de instrucciones bsicas.
Un problema clsico.
43

Complejidad de Instrucciones
Bsicas
for (i = 0; i<n ; i ++ ) {
for (j = i, j<n; j ++) {
if a[j-1] > a[j]
{ temp = a[j];
a[j] = a[j-1];
a[j-1] = temp; }
fi
rof
rof

O(n2)
O(n-1-i)
O(1)
O(1)

44

Complejidad de SORT
Sort Burbuja es O(n2).
Sort por Fusin es O(n log n)

45