Tema 2. Análisis de Complejidad - 2pg

11/9/18
Universidad Politécnica de Madrid

Escuela Técnica Superior de Ingeniería de Sistemas Informá=cos
Tema 2. Análisis de
Complejidad
Algorítmica y Complejidad
Introducción
Problemas y Funciones: Ejemplos
2 4 1 3 2 4 1 3
¿Cuánto tarda el algoritmo en
array array
ordenar?
•  Dependerá del computador donde
Ordenar ALGORITMO:
se ejecuta.
Ordenación por
la lista
Inserción
ESTUDIAREMOS UNA
MEDIDA INDEPENDIENTE
array array DEL COMPUTADOR
1 2 3 4 1 2 3 4
1. Introducción
1
1
11/9/18
Introducción
2 4 1 3 2 4 1 3
array array
ordenar?
•  Dependerá de la ENTRADA (lista a
Ordenar ALGORITMO:
ordenar).
Ordenación por
la lista
Inserción •  Estudiaremos caracterísCcas de la
ENTRADA que reflejen el tamaño
del problema:
array array
•  Número de elementos del
1 2 3 4 1 2 3 4 array (N).
1. Introducción
1
Introducción
1 2 3 4 2 4 1 3
array array
ordenar?
•  Dependerá de la ENTRADA (lista a
ALGORITMO: ALGORITMO:
ordenar).
Ordenación por Ordenación por
Inserción Inserción •  Estudiaremos caracterísCcas de la
del problema:
array array
1 2 3 4 1 2 3 4 array (N).
Para arrays con el mismo número de elementos, el algoritmo tarda un Cempo diferente.
Caso Mejor Caso Promedio Caso Peor
1. Introducción
1
2
11/9/18
Introducción
MoKvación
N: Tamaño del Problema
Problema ALGORITMO 1 ALGORITMO 2
Tarda T1 (N) Tarda T2 (N)
En nuestro computador tenemos que: T2 (N)

t
T1 (N)
Tiempo que 1 h
asumimos para Circunstancia
realizar cómputos Coyuntural
N1 N2
N
ALGORITMO 2 es preferible en nuestro
1. Introducción computador
1
Introducción
MoKvación
A medida que
Compramos un computador con doble capacidad de proceso: T2 (N) aumenta la capacidad
de proceso la
t
diferencia aumenta
T2 (N)
T1 (N)
1 h T1 (N) Los Cempos se

Tiempo que reducen a la
asumimos para mitad
realizar cómputos
N2 N1
N
ALGORITMO 1 es ahora preferible en
1. Introducción nuestro nuevo computador
1
3
11/9/18
Introducción
MoKvación
T2 (N)
Circunstancia t
Coyuntural
T1 (N)
ALGORITMO 2 es
preferible en
T1 (100)
nuestro T2 (100)
computador
100
N
Tamaño del problema actual
1. Introducción
1
Introducción
MoKvación
A medida que
T2 (N) aumenta el tamaño
ALGORITMO 1 es t del problema la
ahora preferible diferencia aumenta
en nuestro T2 (200)
computador T1 (N)
T1 (200)
100 200
N
Tamaño del problema actual
1. Introducción
1
4
11/9/18
Notación AsintóKca
Crecimiento
Notación: O Ω Θ
2 4 1 3
t T (N) ¿Cuánto tarda el algoritmo en
array
ordenar?
Estudiaremos el •  Dependerá de la ENTRADA (lista a
crecimiento ALGORITMO:
ordenar).
asintóKco Ordenación por
Inserción •  Estudiaremos caracterísCcas de la
del problema:
N array
1 2 3 4 array (N).
2. Notación AsintóKca
2
Notación O: Definición
Notación: O T(N)∈ O( f(N) ) Ω T(N)∈ Ω( g(N) ) Θ T(N)∈ Θ( h(N) )
c·f (N)
t T (N) Definición de O “Cota asintó/ca Superior”
f (N)
T(N)∈ O( f(N) ) si y solo si
∃c ∃n0 tal que ∀n>n0 T(n) ≤ c·f(n)
Se puede entender como “T ≤ f”
2
5
11/9/18
Notación O: Definición
c·f (N)
f (N)
n0
2
Notación O: Ejemplo 1
Ejemplo 1
c·f (N)
t f (N) = N2 + 3 T (N)
Definición de O “Cota asintó/ca Superior”
T (N) =2N+3
f (N)
n0
Ejemplo 1 Ejemplo 2
2
6
11/9/18
Ejemplo 1
t f (N) = N2 + 3
T (N) =2N+3
c=1
Ejemplo 1 Ejemplo 2
2
Ejemplo 1
t f (N) = N2 + 3
T (N) =2N+3
c=1 n0 = 2
Ejemplo 1 Ejemplo 2
2
7
11/9/18
Ejemplo 1
Ejemplo 2
t f (N) = N2 + 3
T (N) = 2N+1
T (N) =2N+3
f (N)=N
Ejemplo 1 Ejemplo 2
2
Ejemplo 2
c·f (N) = 3N
T (N) = 2N+1
f (N)=N c=3
Ejemplo 1 Ejemplo 2
2
8
11/9/18
Ejemplo 2
c·f (N) = 3N
T (N) = 2N+1
f (N)=N c=3 n0 = 1
Ejemplo 1 Ejemplo 2
2
Ejemplo 2
c·f (N)
c·f (N) = 3N
T (N) = 2N+1
f (N)
f (N)=N
1 n0
Ejemplo 1 Ejemplo 2
2
9
11/9/18
Notación O: Propiedades
c·f (N)
f (N)
Reflexividad •  f(N)∈O(f(N))
n0
•  f(N)∈O(g(N))
TransiKvidad g(N)∈O(h(N)) ⇒ f(N)∈O(h(N))
2
Notación Ω: Definición
g (N)
t T (N) Definición de Ω “Cota asintó/ca Inferior”
T(N)∈ Ω( g(N) ) si y solo si
c·g (N)
∃c ∃n0 tal que ∀n>n0 T(n) ≥ c·g(n)
Se puede entender como “T ≥ g”
2
10
11/9/18
Notación Ω: Definición
g (N)
c·g (N)
n0
2
Notación Ω: Ejemplo 1
Ejemplo 1
g (N)
t T (N)=N2 + 3 T (N)
g (N) = 2N+3 Definición de Ω “Cota asintó/ca Inferior”
c·g (N)
n0
Ejemplo 1 Ejemplo 2
2
11
11/9/18
Ejemplo 1
t T (N)=N2 + 3
c=1
Ejemplo 1 Ejemplo 2
2
Ejemplo 1
t T (N)=N2 + 3
c=1 n0 = 2
Ejemplo 1 Ejemplo 2
2
12
11/9/18
Ejemplo 1
t T (N)=N2 + 3
c=1 n0 = 2
Ejemplo 1 Ejemplo 2
2
Ejemplo 1
Ejemplo 2
t T (N)=N2 + 3
g (N)=2N+3
T (N) = N Se puede entender como “T ≥ g”
Ejemplo 1 Ejemplo 2
2
13
11/9/18
Ejemplo 2
t
Definición de Ω “Cota asintó/ca Inferior”
g (N)=2N+3
c=0.5
c·g (N) = N+3/2
Ejemplo 1 Ejemplo 2
2
Ejemplo 2
t
Definición de Ω “Cota asintó/ca Inferior”
g (N)=2N+3
c=0.5 n0 = 0
c·g (N) = N+3/2
Ejemplo 1 Ejemplo 2
2
14
11/9/18
Ejemplo 2
g (N)
g (N)=2N+3
c·g (N)

c·g (N) = N+3/2
0 n0
Ejemplo 1 Ejemplo 2
2
Notación Ω: Propiedades
g (N)
c·g (N)
Reflexividad •  g(N)∈ Ω(g(N))

n0
•  g(N)∈ Ω(f(N))
TransiKvidad f(N)∈ Ω(h(N)) ⇒ g(N)∈ Ω(h(N))
Dualidad •  g(N)∈ Ω(f(N)) ⇔ f(N)∈O(g(N))
2
15
11/9/18
Notación Θ: Definición
c2·h (N) h (N)

t T (N) Definición de Θ
c1·h (N)
T(N)∈ Θ( h(N) ) si y solo si
∃c1 ∃c2 ∃n0 tal que ∀n>n0 c1·h(n) ≤ T(n) ≤ c2·h(n)
Se puede entender como “T = h”
2
c2·h (N) h (N)

c1·h (N)
n0
2
16
11/9/18
Notación Θ: Ejemplo 1
Ejemplo 1
c2·h (N) h (N)
t T (N)=2N2T (N)
Definición de Θ
h (N) = N
c1·h (N) + 1
2

n0
Ejemplo 1 Ejemplo 2
2
Ejemplo 1
c2·h (N) = 3N2+ 3
t T (N)=2N2 Definición de Θ
h (N) = N2+ 1
c1=1 c2=3
Ejemplo 1 Ejemplo 2
2
17
11/9/18
Ejemplo 1
c2·h (N) = 3N2+ 3
h (N) = N2+ 1
c1=1 c2=3 n0 = 1
Ejemplo 1 Ejemplo 2
2
Ejemplo 1
Ejemplo 2
T (N) = 4N+13
c2·h (N) = 3N2+ 3
h (N) = N2+ 1
h (N)=2N+3
Ejemplo 1 Ejemplo 2
2
18
11/9/18
Ejemplo 2
c2 h (N)=6N+9 T (N) = 4N+13
t
Definición de Θ
h (N)=2N+3
c1=1 c2=3
Ejemplo 1 Ejemplo 2
2
Ejemplo 2
c2 h (N)=6N+9 T (N) = 4N+13
t
Definición de Θ
h (N)=2N+3
c1=1 c2=3 n0 = 2
Ejemplo 1 Ejemplo 2
2
19
11/9/18
Ejemplo 2
c2 h (N)=6N+9 ·h (N) h (N)
c2T (N) = 4N+13
c1·h (N)
h (N)=2N+3
2 n0
Ejemplo 1 Ejemplo 2
2
Notación Θ: Propiedades
c2·h (N) h (N)

c1·h (N)
Reflexividad •  h(N)∈ Θ(h(N))

n0
Relación de Equivalencia •  g(N)∈ Θ(f(N))
TransiKvidad f(N)∈ Θ(h(N)) ⇒ g(N)∈ Θ(h(N))
Asignatura:
Matemá/ca Discreta Simetría •  f(N)∈ Θ(h(N)) ⇔ h(N)∈ Θ(f(N))
•  f(N)∈ O(h(N))
f(N)∈ Ω(h(N)) ⇔ f(N) ∈ Θ (h(N))
2
20
11/9/18
Jerarquía de Ordenes
“T ≤ f” “T ≥ g” “T = h”
…
O(2N)
O(N3)
O(N2)
O(N·log N)
O(N)
O(log N)
O(1)
2
“T ≤ f” “T ≥ g” “T = h”
… Algoritmos Eficientes
O(2N)
…
O(N3)
O(N2)
O(N·log N)
O(N)
O(log N)
Complejidad
O(1) Constante
No depende de la entrada
2
21
11/9/18
“T ≤ f” “T ≥ g” “T = h”
O(2N)
…
O(N3)
O(N2)
O(N·log N)
O(N) Complejidad
Logarítmica
O(log N)
Búsqueda en
O(1) Búsqueda Binaria un vector
2
“T ≤ f” “T ≥ g” “T = h”
O(2N)
…
O(N3)
O(N2)
Complejidad
O(N·log N)
Lineal
O(N) Máximo de
Algoritmo un array
O(log N)
O(1)
2
22
11/9/18
Algoritmos Quasi-lineales
“T ≤ f” “T ≥ g” “T = h”
O(2N)
…
O(N3)
Complejidad
O(N2) Quasi-Lineal
O(N·log N) Ordenar un
MergeSort array
O(N)
O(log N)
O(1)
2
“T ≤ f” “T ≥ g” “T = h”
…
Problemas tratables
O(2N)
… Complejidad
Cuadrá/ca
O(N3)
O(N2) Ordenación
por Selección
O(N·log N) Ordenar un
O(N) array
O(log N)
O(1)
2
23
11/9/18
“T ≤ f” “T ≥ g” “T = h”
…
Problemas tratables
O(2N)
Complejidad
… Cúbica
O(N3) Algoritmo MulKplicar
O(N2) tradicional Matrices
O(N·log N)
O(N)
O(log N)
O(1)
2
“T ≤ f” “T ≥ g” “T = h”
…
Orden polinomial Problemas tratables
O(2N)
… Problema de
ALGORITMO Kpo P
O(N3)
O(N2)
O(N·log N)
O(N)
O(log N)
O(1)
2
24
11/9/18
Cálculo de la complejidad
“T ≤ f” “T ≥ g” “T = h”
… Orden exponencial
O(2N) ALGORITMO Problema de
“Backtracking” la mochila 0-1
…
O(N3)
O(N2)
O(N·log N)
O(N)
O(log N)
O(1)
2
Otros órdenes de complejidad: O(10N), (N!)
“T ≤ f” “T ≥ g” “T = h”
… O(10N)
O(2N)
…
O(N3)
O(N2)
O(N·log N)
O(N)
O(log N)
O(1)
2
25
11/9/18
Otros órdenes de complejidad: O(log log N)
“T ≤ f” “T ≥ g” “T = h”
…
O(2N)
…
O(N3)
O(N2)
O(N·log N)
O(N)
O(log N)
O(log log N)
O(1)
2
Otros órdenes de complejidad: O(√⁠𝑵 )
“T ≤ f” “T ≥ g” “T = h”
…
O(2N)
…
O(N3)
O(N2)
O(N·log N)
O(N)
O(log N) O(√⁠𝑵 )
O(1)
2
26
11/9/18
Otros órdenes de complejidad: O(N2·log N)
“T ≤ f” “T ≥ g” “T = h”
…
O(2N)
…
O(N3)
O(N2) O(N2·log N)
O(N·log N)
O(N)
O(log N)
O(1)
2
Jerarquía de Órdenes
“T ≤ f” “T ≥ g” “T = h”
…
O(2N)
…
O(N3)
O(N2)
O(N·log N)
O(N)
O(log N)
T(N)∈O(N·log N)
O(1)
2
27
11/9/18
“T ≤ f” “T ≥ g” “T = h”
…
O(2N)
…
O(N3)
O(N2)
O(N·log N)
T(N)∈Ω(N·log N)
O(N)
O(log N)
O(1)
N·log log N
2
“T ≤ f” “T ≥ g” “T = h”
…
O(2N)
…
O(N3)
O(N2)
O(N·log N)
T(N)∈ Θ(N·log N)
O(N)
O(log N)
O(1)
2
28
11/9/18
Operaciones con conjuntos
Sea a una constante •  Θ(a) = Θ(1)
•  a·Θ( f(N) ) = Θ(a·f(N) ) = Θ( f(N) )
•  Θ( f(N) ) + Θ( g(N) ) = Θ( f(N) + g(N) ) = Θ(máx {f(N), g(N)} )
•  Θ( f(N) ) · Θ( g(N) ) = Θ( f(N) · g(N) )
…
T(N)= 21 + 25·N + 34·ln (N)
O(2N) T(N)= 21 + 25·N + 34·ln (N) ∈ Θ(1) + 25·N + 34·ln (N)
… ∈ Θ(1) + Θ(N) + Θ( log (N) ) ∈ Θ(N)
O(N3)
O(N2)
O(N·log N)
O(N)
O(log N)
O(1)
2
Ejemplos
… T(N) = N!
O(2N) T(N) = 2N + 7234·N200 + 273
… T(N) = 5·N2 + 7N + 27903

O(N3)
T(N) = 2N·log (N2)+32·N+345
O(N2)
O(N·log N) T(N) = log (N) + 5·N +23
O(N) T(N) = 23·N+43

O(log N)
T(N) = log (N2)
O(1)
T(N) = 5·ln(N)
T(N) = 52
2
29
11/9/18
AcKvidades
AcKvidad 2.3. Un algoritmo Cene orden de complejidad O(N). Si

para un tamaño N=10, el algoritmo tarda 2 segundos en nuestro
computador.
a)  ¿Podemos conocer cuánto tardará el algoritmo para un tamaño
N=20?
b)  ¿Podemos dar una cota superior de cuánto tardará el
algoritmo?
2
AcKvidades

computador.
N=20? NO
algoritmo?
•  T1(N) = 0.01·N + 1.90 •  T2(N) = 0.2·N

T1(N) ∈ O(N) T2(N) ∈ O(N)
T1(10) = 2 s. T2(10) = 2 s.
T1(20) = 2.1 s. T2(20) = 4 s.
2
30
11/9/18
AcKvidades

computador.
N=20?
algoritmo? NO
2 si N<=10
Tk(N) =
Tk(N) ∈ O(N) k N si N>10
Tk(10) = 2
Tk(20) = 20·k
2
AcKvidades
AcKvidad 2.4. Considérese dos algoritmos:
•  El algoritmo A1 Cene orden de complejidad Θ(N).
•  El algoritmo A2 Cene orden de complejidad Θ(N2).
¿ El algoritmo A1 tarda siempre menos que A2 ? NO
•  T1(N) = 1000·N •  T2(N) = N2

T1(N) ∈ Θ(N) T2(N) ∈ Θ(N2)
T1(10) = 10000 s. T2(10) = 100 s.
2
31
11/9/18
Complejidad en algoritmos sencillos

Instrucciones Sencillas
Instrucciones Secuencia Condiciones Bucles
básicas
? ?
3. Complejidad en Algoritmos Sencillos

3

básicas
? ?
… … …
a = 3; a = b; return (b+2)*3-7/3;
… … … …
asignación de variables expresiones aritméCcas
T(N)= constante
Θ(1)

3
32
11/9/18

básicas
? ?
… … …
a = 3; a = b; return (b+2)*3-7/3;
… … … … N: Tamaño de vector[]
asignación de variables expresiones aritméCcas int primero(int[] vector) {

return vector[0];
T(N)= constante }
T(N)∈ Θ(1) T(n) ∈ Θ(1)

3

Secuencias
Instrucciones Secuencia
Secuencia Condiciones Bucles
básicas
? ?
…
P1; T1(N)
T(N)
P2; T2(N)
…
T(N)= T1(N) + T2(N)
T(N)∈ Θ(max {T
T(N)∈ Θ(T1(N)) + Θ(T
1(N), T2(N)} )
(N))

3
33
11/9/18

Secuencias: Ejemplo
Instrucciones Secuencia
Secuencia Condiciones Bucles
básicas
? ?
…
P1; T1(N)
T(N) N: Tamaño de vector[]
P2; T2(N)
…
int maxValor(int[] vector) {
ordenar(vector); Θ(N·log N)
return vector[0]; Θ(1)
T(N)= T1(N) + T2(N) }
T(N)∈ Θ(max {T1(N), T2(N)} ) T(n) ∈ Θ(N·log N)+Θ(1) = Θ(N·log N)

3

Secuencias
AcKvidad 2.7. Calcula la complejidad del siguiente algoritmo en

función del tamaño del vector.
N: Tamaño de vector[]
boolean contiene(int vector[], int elemento) {

ordenar(vector); Θ(N·log N)
return busquedaOrdenada(vector, elemento); Θ(log N)
}
T(n) ∈ Θ(N·log N)+Θ(log N) = Θ(N·log N)

3
34
11/9/18

Condición: if …
básicas
? ?
…
if (c) { Tc(N)
P1;
T1(N)
}
else {
P2; T2(N)
} CASO PEOR
…
T(N)= Tc(N) + max{T1(N), T2(N)}
Θ(max {Tc(N), T1(N), T2(N)} )

3

Condición: if …
básicas
? ?
…
if (c) { Tc(N) N: Tamaño de vector[]
P1;
T1(N) int primeroAbs(int[] vector) {
}
else { if (vector[0]<0) Θ(1)
return -vector[0]; Θ(1)
P2; T2(N) else
} CASO PEOR return vector[0]; Θ(1)
… }
T(N)= Tc(N) + max{T1(N), T2(N)}
T(n) ∈ Θ(1) + max{Θ(1), Θ(1)} = Θ(1)
Θ(max {Tc(N), T1(N), T2(N)} )
3
35
11/9/18

Secuencias

void borrarElemento(int[] vector, int e) {

int p = buscar(vector, elemento); Θ(log N)
if (p>=0)
desplazarVector(vector,p); Θ(N)
}
CASO PEOR
T(n) ∈ Θ(log N) + Θ(N) = Θ(N)

3

Bucle: for…
Bucles
básicas
? ?
… …
for (int i=1; i<m(N); i++) { while(c)
P(i); P;
} }
… …
T(N)= 𝑐 +∑𝑖=1↑𝑚(𝑁)▒𝑇↓𝑃 (𝑖, 𝑁) } T(N)= Depende del caso

3
36
11/9/18

Bucle: for…
Bucles
básicas
? ?
int factorial(int n) {
int r=1; Θ(1)
n
for (int i=1; i<=n; i++)
r=r*i; Θ(1) Θ(n) ∑Θ(1) =𝑛·Θ(1)=𝚯(𝒏)
return r; Θ(1) i=1
}
T(n) ∈ Θ(1)+Θ(n)+ Θ(1) = Θ(n)

3

Bucle: for…

función de n.
int func1(int n) { n i
int l=0; Θ(1) = ∑∑ Θ(1)
for (int i=1; i<=n; i++)
i=1 j=1
for (int j=1; j<=i; j++) Θ(n2)
l++; Θ(1) n n
return l; Θ(1) = ∑ i ⋅ Θ(1) = Θ(1)∑ i

} i=1 i=1
n +1
= Θ(1)⋅ n ⋅ ∈ Θ(n 2 )
T(n) ∈ Θ(1)+Θ(n2)+ Θ(1) = Θ(n2) 2

3
37
11/9/18

Bucle: for…

función de n.
int func2(int n) {
int l=0; Θ(1) n i n
for (int i=1; i<=n; i++) = ∑∑∑ Θ(1)

for (int j=1; j<=i; j++) i=1 j=1 k=1
for (int k=1; k<=n; k++) Θ(n3)
n i n n
l++; Θ(1) = ∑ ∑ n = ∑ i ⋅ n = n∑ i
return l; Θ(1) i=1 j=1 i=1 i=1
}
n(n +1)
= n⋅ ∈ Θ(n 3 )
T(n) ∈ Θ(1)+Θ(n3)+ Θ(1) = Θ(n3) 2

3

Bucle: for…

función de n.
int func3(int n) {
int l=0; Θ(1) n−1 n 2 −1 n3 −1
for (int i=0; i<n; i++) = ∑ ∑ ∑ Θ(1)

for (int j=0; j<n*n; j++) i=0 j=0 k=0
for (int k=0; k<n*n*n; k++) Θ(n6)
n−1 n 2 −1 n−1
l++; Θ(1) = ∑ ∑ n3 = ∑ n 2 ⋅ n3
return l; Θ(1) i=0 j=0 i=0
}
= n ⋅ n 2 ⋅ n 3 ∈ Θ(n 6 )
T(n) ∈ Θ(1)+Θ(n6)+ Θ(1) = Θ(n6)

3
38
11/9/18

Bucle: for…

int suma(int[] vector) {

int l=0; Θ(1) n−1
for (int i=0; i<vector.length; i++)
l+=vector[i]; Θ(1)
Θ(N) ∑Θ(1) = N ∈ Θ(N )
i=0
return l; Θ(1)
}
T(n) ∈ Θ(1)+Θ(N)+ Θ(1) = Θ(N)

3

Bucle: for…

función del tamaño del vector de entrada.
int max(int[] vector) {

int m=Integer.MIN_VALUE; Θ(1) n−1
for (int i=0; i<vector.length; i++)
if (vector[i]>=m) m = vector[i]; Θ(1) Θ(N) ∑Θ(1) = N ∈ Θ(N )
return m; i=0
Θ(1)
}
T(N) ∈ Θ(1)+Θ(N)+ Θ(1) = Θ(N)

3
39
11/9/18

Bucle: for…

función del tamaño del vector de entrada.
int min_distancia(int[] x) {
int n=x.length;
n: Tamaño del vector x[]
int d=Integer.MAX_VALUE; Θ(1) n−1 n−1
for (int i=0; i<n; i++)

= ∑ ∑ Θ(1)
i=0 j=i+1
for (int j=i+1; j<n; j++) {
int d2 = x[i]-x[j]; n−1
Θ(n2)
if (d2<0) d2=-d2; Θ(1) = ∑ n − (i +1)
if (d2<d) d=d2; i=0
}
return d; Θ(1) n(n −1)
} = ∈ Θ(n 2 )
2
T(n) ∈ Θ(1)+Θ(n2)+ Θ(1) =Θ(n2)

3

Bucle: while…
Bucles
básicas
? ?
… …
for (int i=1; i<m(N); i++) { while(c)
P(i); P;
} }
… …
T(N)= 𝑐 +∑𝑖=1↑𝑚(𝑁)▒𝑇↓𝑃 (𝑖, 𝑁) } T(N)= Depende del caso

3
40
11/9/18

Ejemplo bucle: while…
Bucles
básicas
? ?
Caso Peor Caso Promedio Caso Mejor

boolean contieneValor (int[] vector, int elemento){
boolean encontrado = false;
int i = 0;
while (i<vector.length && !encontrado) {
¿ Nº de
if (vector[i] == elemento) encontrado = true; Dependerá del
Iteraciones?
i++; caso concreto
}
return encontrado;
}
N:Tamaño del vector
(vector.length)
3

Caso Peor: Bucles
Bucles
•  El array NO conCene el elemento.
?

boolean encontrado = false; Siempre se cumple:
int i = 0; encontrado: false
Se ejecuta
if (vector[i] == elemento) encontrado = true;
N veces
i++;
} Consideramos que siempre
return encontrado; se cumple:
} vector[i]!=elemento
(vector.length)
3
41
11/9/18

Caso Peor: Bucles
Bucles
•  El array NO conCene el elemento.
?
Θ(N)
int i = 0;
Θ(1)
Se ejecuta
Θ(1)
N veces
i++;
}
return encontrado; Θ(1)
}
T(N) ∈ Θ(1) + N·Θ(1) + Θ(1) =Θ(N) (vector.length)
3

Caso Mejor: Bucles
Bucles
•  El array conCene el elemento en su primera posición.
?

boolean encontrado = false; Para i:1
int i = 0; encontrado:true
Se ejecuta
1 vez
i++;
} Consideramos que se
return encontrado; cumple:
} vector[0]==elemento
(vector.length)
3
42
11/9/18

Caso Mejor: Bucles
Bucles
•  El array conCene el elemento en su primera posición.
?
Θ(1)
int i = 0;
Θ(1)
Se ejecuta
Θ(1)
1 vez
i++;
}
}
T(N) ∈ Θ(1) + 1·Θ(1) + Θ(1) =Θ(1) (vector.length)
3

¿Distribución de probabilidad sobre donde se encuentra el Bucles
Bucles
elemento en el vector?
•  El elemento Cene la misma probabilidad de encontrarse ?
por primera vez en cada uno de los componentes del array.

int i = 0;
i++;
}
return encontrado;
}
(vector.length)
3
43
11/9/18

Bucles

boolean encontrado = false; Para i: N/2
int i = 0; encontrado:true
Se ejecuta
N/2 veces
i++;
return encontrado; cumple:
} Para i:1…N/2-1
vector[i]!=elemento
vector[N/2]==elemento N:Tamaño del vector
(vector.length)
3

Bucles
Θ(N)
int i = 0;
Θ(1)
Se ejecuta
Θ(1)
N/2 veces
i++;
}
}
T(N) ∈ Θ(1) + N/2·Θ(1) + Θ(1) =Θ(N) (vector.length)
3
44
11/9/18

Bucles
Bucles
Θ(N) Θ(N) Θ(1)

int i = 0;
Θ(1)
i++;
}
}
(vector.length)
3

Bucle: while …

boolean esta_Ordenado (int[] vector){

boolean ordenado = true;
int i = 1;
while (i<vector.length && ordenado) {
if (vector[i-1] > vector[i]) ordenado= false;
i++;
}
return ordenado;
}
(vector.length)
3
45
11/9/18

Bucle: while …


int i = 1;
¿ Nº de
if (vector[i-1] > vector[i]) ordenado= false; Dependerá del
Iteraciones?
i++; caso concreto
}
return ordenado;
}
(vector.length)
3

Bucle: while …

Caso Peor: El array ESTÁ ordenado.

boolean ordenado = true; Siempre se cumple:
int i = 1; ordenado: true
Se ejecuta
N-1 veces
i++;
} Consideramos que siempre
return ordenado; se cumple:
} vector[i-1]<=vector[i
]
(vector.length)
3
46
11/9/18

Bucle: while …

Caso Peor: El array ESTÁ ordenado.
Θ(N)
int i = 1; Θ(1)
Se ejecuta
Θ(1)
N-1 veces
i++;
}
return ordenado; Θ(1)
}
T(N) ∈ Θ(1) + (N-1)·Θ(1) + Θ(1) =Θ(N) (vector.length)
3

Bucle: while …

Caso Mejor: Los dos primeros elementos están desordenados.

boolean ordenado = true; Para i:2
int i = 1; ordenado:false
Se ejecuta
1 vez
i++;
return ordenado; cumple:
} vector[0]>vector[1]
(vector.length)
3
47
11/9/18

Bucle: while …

Caso Mejor: Los dos primeros elementos están desordenados.
Θ(1)
int i = 1; Θ(1)
Se ejecuta
Θ(1)
1 vez
i++;
}
return ordenado; Θ(1)
}
T(N) ∈ Θ(1) + 1·Θ(1) + Θ(1) =Θ(1) (vector.length)
3

Bucle: while …

¿Distribución de probabilidad de los elementos del vector?

int i = 1;
i++;
}
return ordenado;
}
(vector.length)
3
48

Tema 2. Análisis de Complejidad - 2pg

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tema 2. Análisis de Complejidad - 2pg

Cargado por

Copyright:

Formatos disponibles

11/9/18

Universidad Politécnica de Madrid

Caso Mejor Caso Promedio Caso Peor

Problema ALGORITMO 1 ALGORITMO 2

Tarda T1 (N) Tarda T2 (N)

En nuestro computador tenemos que: T2 (N)

Problema ALGORITMO 1 ALGORITMO 2

Tarda T1 (N) Tarda T2 (N)

1 h T1 (N) Los Cempos se

Problema ALGORITMO 1 ALGORITMO 2

Tarda T1 (N) Tarda T2 (N)

Problema ALGORITMO 1 ALGORITMO 2

Tarda T1 (N) Tarda T2 (N)

Se puede entender como “T ≤ f”

Se puede entender como “T ≤ f”

Se puede entender como “T ≤ f”

Se puede entender como “T ≤ f”

Se puede entender como “T ≥ g”

Se puede entender como “T ≥ g”

Se puede entender como “T ≥ g”

T (N) = N Se puede entender como “T ≥ g”

T (N) = N Se puede entender como “T ≥ g”

Se puede entender como “T ≥ g”

Reﬂexividad • g(N)∈ Ω(g(N))

Dualidad • g(N)∈ Ω(f(N)) ⇔ f(N)∈O(g(N))

c2·h (N) h (N)

Se puede entender como “T = h”

c2·h (N) h (N)

Se puede entender como “T = h”

T(N)∈ Θ( h(N) ) si y solo si

Se puede entender como “T = h”

Se puede entender como “T = h”

Se puede entender como “T = h”

c2·h (N) h (N)

Se puede entender como “T = h”

Reﬂexividad • h(N)∈ Θ(h(N))

O(2N) T(N) = 2N + 7234·N200 + 273

… T(N) = 5·N2 + 7N + 27903

O(N) T(N) = 23·N+43

AcKvidad 2.3. Un algoritmo Cene orden de complejidad O(N). Si

AcKvidad 2.3. Un algoritmo Cene orden de complejidad O(N). Si

• T1(N) = 0.01·N + 1.90 • T2(N) = 0.2·N

AcKvidad 2.3. Un algoritmo Cene orden de complejidad O(N). Si

• T1(N) = 1000·N • T2(N) = N2

T1(10) = 10000 s. T2(10) = 100 s.

Complejidad en algoritmos sencillos

3. Complejidad en Algoritmos Sencillos

Complejidad en algoritmos sencillos

asignación de variables expresiones aritméCcas

3. Complejidad en Algoritmos Sencillos

Complejidad en algoritmos sencillos

asignación de variables expresiones aritméCcas int primero(int[] vector) {

T(N)∈ Θ(1) T(n) ∈ Θ(1)

3. Complejidad en Algoritmos Sencillos

Complejidad en algoritmos sencillos

T(N)= T1(N) + T2(N)

3. Complejidad en Algoritmos Sencillos

Complejidad en algoritmos sencillos

T(N)∈ Θ(max {T1(N), T2(N)} ) T(n) ∈ Θ(N·log N)+Θ(1) = Θ(N·log N)

3. Complejidad en Algoritmos Sencillos

Complejidad en algoritmos sencillos

AcKvidad 2.7. Calcula la complejidad del siguiente algoritmo en

boolean contiene(int vector[], int elemento) {

Reﬂexividad •  g(N)∈ Ω(g(N))

Dualidad •  g(N)∈ Ω(f(N)) ⇔ f(N)∈O(g(N))

Reﬂexividad •  h(N)∈ Θ(h(N))

•  T1(N) = 0.01·N + 1.90 •  T2(N) = 0.2·N

•  T1(N) = 1000·N •  T2(N) = N2

T(N)= 𝑐 +∑𝑖=1↑𝑚(𝑁)▒𝑇↓𝑃 (𝑖, 𝑁) } T(N)= Depende del caso

T(N)= 𝑐 +∑𝑖=1↑𝑚(𝑁)▒𝑇↓𝑃 (𝑖, 𝑁) } T(N)= Depende del caso