Algoritmos y Estructuras de Datos I

CAPITULO 1: ANÁLISIS DE ALGORITMOS

Un algoritmo es un conjunto de instrucciones claramente

especificadas que el ordenador debe seguir para resolver un
problema. Una vez que se ha dado un algoritmo para resolver un
problema y se ha probado que es correcto, el siguiente paso es
determinar la cantidad de recursos, tales como tiempo y espacio,
que el algoritmo requerirá para su aplicación. Este paso se llama
análisis de algoritmos. Un algoritmo que necesita varios
gigabytes de memoria principalmente no es útil en la mayoría de
las maquinas actuales.

1.1 Complejidad de Algoritmos

ƒ Algoritmo: Instrucciones I1,I2,….,Ik.
ƒ Complejidad de Tiempo: El tiempo que se demora en llevar a
cabo todas las instrucciones.
ƒ Complejidad de espacio: Espacio que requiere el algoritmo.
ƒ Tiempo: Tiempo de las instrucciones t1,t2,…..,tk
ƒ Frecuencia: Veces que se ejecuta la instrucción f1, f2,……, fk.

En general, para un algoritmo la complejidad se calculará

recorriendo todas las instrucciones, obteniendo la frecuencia de
ella.
k
CT = ∑ f i ⋅ ti
i =1

1
Algoritmos y Estructuras de Datos I

Simplificación: t1=t2=….tk=cte=1
k
CT = ∑ f = Nro de pasos
i =1

Para un algoritmo
ƒ Entrada : Datos que se ingresan al algoritmo
ƒ Instancia: Valor particular de la entrada.
ƒ Paso: Instrucción simple
ƒ Instrucción simple: calculo de variables simples.

Ejemplo1: Suma de Matrices

Entrada: A, B ∈ Μ (m × n ), m, n
Salida: C = A + B ∈ Μ (m × n ) cij = aij + bij

Para i=1 hasta m hacer

Para j=1 hasta n hacer
cij = aij + bij

Fin Para
Fin Para

Complejidad de tiempo: m*n*t1

ƒ Complejidad del peor caso: Tiempo necesario para la entrada

más desfavorable siendo E1, E2,….,Ek todas las posibles
entradas al algoritmo. [ ]
max t (E j ) = C PC
1≤ j ≤ k

2
Algoritmos y Estructuras de Datos I

ƒ Complejidad del mejor caso: C MC = min t (E j ) [ ]

1≤ j ≤ k

ƒ Complejidad del Caso Medio: CCM = ∑ p j t (E j )

k

j =1

Ejemplo 2: Factorial

Entrada: n
Salida : n!
Si n=0 entonces
nfactorial =1
Caso contrario
aux =1
Para i=1 hasta n hacer
aux = aux * i
Fin Para
nfactorial = aux
Fin Si

ƒ Complejidad Peor Caso: CPC = n+4

ƒ Complejidad Mejor Caso: CMC =2
ƒ Complejidad Caso Medio:
n n
CCM = ∑t j ⋅ p j = p 0 + ∑ ( j + 3) ⋅ p j
j =0 j =1

1
pj = j = 0,1,K , n
n +1

3
Algoritmos y Estructuras de Datos I

1 1 n 1 n
CCM = + ∑ j + n +1∑3
n + 1 n + 1 j =1 j =1

1 1 n 1
CCM = + ∑
n + 1 n + 1 j =1
j +3
n +1
1 1 n(n + 1) 3n
CCM = + ⋅ +
n +1 n +1 2 n +1
CCM =
1
(1 + 3n ) + n ~ O(n )
n +1 2

1.2 Notación Ο : Cota Superior de Funciones

Sea f : R → R + y h : N → R + f es del orden de h ( f ~ Ο(h ) ) si

∃ constantes c > 0 y n0 > 0 tales que f (n ) ≤ ch(n ) ∀n ≥ n0

ch h A partir de un punto, h
siempre será mayor que
f. Siempre la velocidad
f
de crecimiento de h es
mayor que f.

4
Algoritmos y Estructuras de Datos I

Ejemplos:
( )
3n 2 + 5 ~ Ο n 2
5n 3 ~ O ( n 3 )
n + n3 ~ O n3 ( )
5nm ~ O(nm )
3n + 4m + 10 ~ O(n + m )
Propiedades
1) O( f ) + O( g ) = O( f + g )
2) O( f ) ⋅ O( g ) = O( f ⋅ g )
3) k cte > 0 O(kf ) = kO( f ) = O( f )
4) f ~ O(h ), h ~ O( g ) ⇒ f ~ O( g )
5) h ≥ g O( g + h ) = O(h )

Algoritmo Eficiente: Si su complejidad del peor caso es un

polinomio en la entrada.
Cpc= O(p(entrada))

Ejemplo: Suma de Matrices ~ O(mn)

Es intratable si está acotado por una función de crecimiento más

rápido que polinomial.

Jerarquía de órdenes de crecimiento

( ) ( ) ( )
O(1) < O(log n ) < O(n ) < O(n log n ) < O n 2 < O n3 < O 2 n ...etc

5
Algoritmos y Estructuras de Datos I

1.3 Notación Ω : Cota Inferior de Funciones

f ~ Ω(h ) si ∃ c, n0 ∈ N tales que f (n ) ≥ ch(n ) ∀n ≥ n0

Límite inferior de un problema es un valor tal que cualquier

algoritmo que resuelva ese problema, tendrá una complejidad
mayor o igual a ese valor (L).
L tq ∀A lg orit C ~ Ω
C≥L
Dado un problema P con límite inferior L, A un algoritmo que
resuelve P tal que C pc ( A) ~ O(L ) entonces A es óptimo.

Aplicación 1: Búsqueda
Problema: Dado un conjunto de n elementos S = {x1 , x 2 ,K, x n } y
un elemento x. Determinar si x pertenece a S.
Algoritmo1: Búsqueda lineal
Entrada: n, S, x
Salida: SI, NO

6
Algoritmos y Estructuras de Datos I

Para j=1 hasta n hacer

Si xj =x entonces
Devolver SI, j
Fin Si
Fin Para
Devolver NO
ƒ Complejidad Mejor Caso
x = x1
C MC ~ O(1)
T ( n) = 2
ƒ Complejidad Peor Caso
x = xn o x ∉ S
C PC = O(n )
ƒ Complejidad Caso Medio
Entradas
E j : {x = x j } j = 1, K , n
En +1 : {x ∉ S }
Sea q = Pr{x ∉ S }
1 − q = Pr{x ∈ S }
n +1
CCM = ∑ p (E j )⋅ t (E j )
j =1
n
1− q 1− q n
CCM =∑ j + qn = ∑ j + qn
j =1 n n j =1

1 − q n(n + 1)
CCM = ⋅ + qn
n 2
CCM =
(1 − q )(n + 1) + qn
2

7
Algoritmos y Estructuras de Datos I

– Si q~0 , si se está seguro que el elemento que exista

n
CCM =
2
– Si q~1, si es muy probable que el elemento no pertenezca
CCM = n
– Si q~1/2 , es igual de probable que pertenezca y que no
3n
pertenezca CCM =
4

1.4 Complejidad de Algoritmos Recursivos

ƒ Función Recursiva: Es una función f que se define en términos
de ella misma.

Ejemplo 1: Factorial
Def.
n! = 1 si n=0
n!= 1*2*3*4…*(n-1) * n, n ∈ Ν
Prop: n!=n*(n-1)!

ƒ Algoritmo Recursivo: Es un procedimiento que se invoca a sí

mismo, modificando sus argumentos.
ƒ Recursión: Método de descomposición de un problema en
subproblemas de la misma naturaleza que son más simples de
resolver. La solución del problema original se obtiene
combinando las soluciones de los subproblemas.

8
Algoritmos y Estructuras de Datos I

Ejemplo 1: Factorial Recursivo

Entrada: n ∈ N
Salida: n!

Procedimiento FACTO(k)
Si k<=1 entonces
fact =1
Caso contrario
fact =k*FACTO(k-1)
Fin Si
Fin Procedimiento

Complejidades
Sea T(n)= tiempo en calcular n!
T(n) = T(n-1)+1
=[T(n-2)+1]+1= T(n-2)+2
=[T(n-3)+1]+2= T(n-3)+3
.
.
.
=T(n-i)+i si i=n-1
=T(1)+n-1
=1+n-1
=n

9
Algoritmos y Estructuras de Datos I

Dado que el algoritmo recursivo se invoca a sí mismo, al expresar

el orden T(n) de su complejidad se obtiene una ecuación de
recurrencia.

Reducción por Sustracción: Si el tamaño n del problema decrece

en una cantidad constante b en cada llamada, se realizan a
llamadas recursivas y las operaciones correspondientes a la parte
no recursiva del algoritmo toman un tiempo O(nk) entonces:
( )
T (n ) = aT (n − b ) + O n k si n ≥ b

La solución de esta ecuación de recurrencia es de la forma:

⎧n k si a < 1⎫
⎪⎪ ⎪⎪
T (n ) = ⎨n k +1 si a = 1⎬
⎪ n/b ⎪
⎪⎩a si a > 1⎪⎭

En factorial
T(n)=T(n-1)+1
Tenemos
a=1
b=1
k=0
O(n)=nk+1

Reducción por División: Si el algoritmo con un problema de

tamaño n realiza a llamadas recursivas con subproblemas de
tamaño n/b y las operaciones correspondientes a la parte no

10
Algoritmos y Estructuras de Datos I

recursiva (que corresponde a descomponer el problema en los

subproblemas y luego combinar las soluciones de éstos), toman
un tiempo O (nk) entonces:
( )
T (n ) = aT (n / b ) + O n k si n ≥ b

La solución de esta ecuación de recurrencia es de la forma:

⎧n k si a < b k ⎫
⎪⎪ k k ⎪
⎪
( )
T n = ⎨n log n si a = b ⎬
⎪ logb a ⎪
⎪⎩n si a > b k ⎪⎭

Ejemplo:
T(n)=T(n/2)+1
a=1
b=2
k=0
T(n)~O(log n)

El algoritmo recursivo sirve si la descomposición es eficiente, es

decir, cuando un subproblema ya se resolvió no se vuelve a
resolver.

11