Análisis de Algoritmos1
-
Upload
george-bandicoot -
Category
Documents
-
view
220 -
download
0
description
Transcript of Análisis de Algoritmos1
![Page 2: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/2.jpg)
Contenido
Consideraciones.
Complejidad algorítmica. Análisis de estructuras de control.
2
![Page 3: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/3.jpg)
Consideraciones
![Page 4: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/4.jpg)
Consideraciones
¿Dado un problema será posible encontrar más de un algoritmo que sea correcto?
4
![Page 5: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/5.jpg)
Algoritmo de Fibonacci
int fibonacci(int n) {
if (n == 0) return 0;
if (n == 1) return 1;
a = 0; b = 1;
while (n >= 2) {
c = a + b;
a = b; b = c;
n = n - 1;
}
return c;
}
Jhonny Felipez A. - 2011 5
![Page 6: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/6.jpg)
Consideraciones. Cont.
Dado que sea cierto lo anterior:
¿Cómo elegir el mejor de ellos?
6
![Page 7: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/7.jpg)
Consideraciones. Cont.
Criterio posible: Cantidad de recursos consumidos por el algoritmo.
Espacio de memoria.
Tiempo de ejecución.
7
![Page 8: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/8.jpg)
Consideraciones. Cont.
De lo anterior se ocupa el:
Análisis de la complejidad de algoritmos
8
![Page 9: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/9.jpg)
Complejidad Algorítmica
![Page 10: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/10.jpg)
Complejidad de Algoritmos
¿Qué es la complejidad de algoritmos?
La complejidad de algoritmos obtiene una medida de la cantidad que consume un algoritmo de un recurso determinado (espacio o tiempo).
10
![Page 11: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/11.jpg)
Complejidad de Algoritmos
11
Tiempo Espacio
![Page 12: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/12.jpg)
Complejidad de Algoritmos. Cont.
Por ejemplo existe: La Complejidad Espacial o la eficiencia en
la memoria, que toma en cuenta a la cantidad de memoria que ocupan todas las variables del algoritmo (no se vera en la materia).
La Complejidad Temporal o la eficiencia en el tiempo de ejecución.
12
![Page 13: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/13.jpg)
Complejidad de Algoritmos. Cont.
Existen dos métodos para obtener la complejidad algorítmica.
Estimación teórica o a priori.
Verificación empírica o a posteriori.
13
![Page 14: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/14.jpg)
Complejidad de Algoritmos. Cont.
El método empírico también denominado a posteriori, consiste en implementar en un computador los algoritmos a comparar, se prueban para distintos tamaños de los datos del problema y se comparan.
14
![Page 15: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/15.jpg)
Complejidad de Algoritmos. Cont.
El método teórico también denominado a priori, consiste en determinar matemáticamente la cantidad de recursos necesitados por cada algoritmo como una función cuya variable independiente es el tamaño de los datos del problema.
15
![Page 16: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/16.jpg)
Complejidad Algorítmica
Estimación teórica o a priori
![Page 17: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/17.jpg)
Estimación teórica o priori
Suponiendo que en algún lugar de nuestro programa se tiene la siguiente instrucción: x = x + 1 ¿Cuánto tiempo tarda en ejecutarse esta instrucción? ¿Cuál es el número de veces que ésta instrucción se ejecuta? El producto de ambos resultados nos dará el tiempo total que toma esta instrucción! La respuesta a la segunda pregunta se conoce como frecuencia de ejecución
17
![Page 18: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/18.jpg)
Estimación teórica o priori Es imposible determinar exactamente cuanto
tarda en ejecutar una instrucción a menos que se tenga la siguiente información: Características de la máquina.
Conjunto de instrucciones de la maquina.
Tiempo que tarda una instrucción de maquina.
Compilador utilizado.
Lo cual es difícil si se elige una maquina real!.
18
![Page 19: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/19.jpg)
Estimación teórica o priori
Otro alternativa para aproximar cuanto tarda en ejecutar una instrucción quizá será definir una maquina hipotética (con tiempos de ejecución imaginarios).
19
![Page 20: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/20.jpg)
Estimación teórica o priori
En ambos casos el tiempo exacto que se determina no es aplicable a muchas maquinas o a ninguna máquina
Más aún es más dificultoso obtener cifras exactas en tiempo por las limitaciones del reloj y el ambiente de multiprogramación o tiempo compartido
20
![Page 21: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/21.jpg)
Estimación teórica o priori
Todas estas consideraciones nos limitan solamente a obtener la frecuencia de ejecución de todas las instrucciones para un análisis a priori.
21
![Page 22: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/22.jpg)
Complejidad Algorítmica
Estructuras de Control
![Page 23: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/23.jpg)
Análisis de Estructuras. Análisis a priori. Cont.
Consideremos tres simple programas. . .
x = x + 1 . .
La cantidad de frecuencia es uno 23
![Page 24: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/24.jpg)
Análisis de Estructuras. Análisis a priori. Cont.
for i = 1 to n do x = x + 1 end
La misma sentencia será ejecutada n veces en el programa.
24
![Page 25: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/25.jpg)
Análisis de Estructuras. Análisis a priori. Cont.
for i = 1 to n do for j = 1 to n do x = x + 1 end end
n2 veces (asumiendo n 1)
25
![Page 26: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/26.jpg)
Análisis de Estructuras. Análisis a priori. Cont.
1, n y n2 son diferentes.
Si n = 10 aumentaran en un orden de magnitud próximo a 1, 10 y 100.
En nuestro análisis de ejecución principalmente determinaremos el Orden de Magnitud de un algoritmo. Esto significa, determinar aquellas sentencias que tiene una frecuencia de ejecución grande.
26
![Page 27: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/27.jpg)
Análisis de Estructuras. Análisis a priori. Cont.
Para determinar el Orden de Magnitud, a menudo se presentan fórmulas tales como
i i, , 2
ninini
111
1
27
![Page 28: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/28.jpg)
Análisis de Estructuras. Análisis a priori. Cont.
Formas simples para las tres formulas anteriores se tienen:
En general
6
1) + 1)(2n + n(n ,
2
1) + n(n n,
0k grado, menor de terminos + 1+k
n = i
1+kk
ni
1
28
![Page 29: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/29.jpg)
Análisis de Estructuras. Ejemplo método a priori.
Calcular el número n-ésimo de Fibonacci. La secuencia Fibonacci comienza como sigue
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...
Cada nuevo término es obtenido tomando la suma de los dos anteriores términos. Si llamamos al primer término de la secuencia F0, entonces F0 = 0, F1 = 1 y en general
Fn = Fn-1 + Fn-2, n 2
29
![Page 30: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/30.jpg)
Análisis de Estructuras. Ejemplo obtiene la cantidad de frecuencia para n > 1
Paso Algoritmo Frecuencia 1
2-3
4-5
6-7
8
9
10
11
12
13
void fibonacci(int n)
{
int a, b, c, i;
if (n < 0) { printf("Error"); return;}
if (n == 0) { printf("0"); return;}
if (n == 1) { printf("1"); return;}
a = 0; b = 1;
for (i = 2; i <= n; i++)
{
c = a + b;
a = b;
b = c;
}
printf("%d\n",c);
}
t(n) =
1 1 1 1 2 n n-1 n-1 n-1 1
4n + 4 30
![Page 31: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/31.jpg)
Análisis de Estructuras. Ejemplo método a priori . Cont.
El tiempo de cálculo es 4n + 4.
Ignorando las dos constantes 4, obtenemos que la complejidad algorítmica u Orden de Complejidad es O(n).
31
![Page 32: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/32.jpg)
Análisis de Estructuras. Mejor caso y peor caso.
El tiempo que toma un algoritmo puede variar considerablemente en función a las diferentes entradas de datos.
Para el ejemplo con n>1 se da en el peor de los casos y el Orden de Complejidad será O(n).
En el mejor de los casos se da con n = 0 o 1, entonces el algoritmo tendrá una complejidad constante O(1).
En la materia se solicitará obtener en el peor de los casos.
32
![Page 33: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/33.jpg)
Complejidad en el peor de los casos
La complejidad en el peor de los casos de un algoritmo es la función definida por el máximo número de pasos que toma en cualquier instancia de tamaño n.
33
![Page 34: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/34.jpg)
Complejidad mejor y promedio de los casos
La complejidad en el mejor de los casos de un algoritmo es la función definida por el mínimo número de pasos que toma en cualquier instancia de tamaño n.
La complejidad en el caso promedio de un algoritmo es la función definida por el número promedio de pasos que toma en cualquier instancia de tamaño n.
En cada una de estas complejidades se define una función numérica: tiempo vrs tamaño!
34
![Page 35: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/35.jpg)
Complejidad de Algoritmos. Complejidades mas usuales.
O(1) Complejidad constante.
O(log n) Complejidad logarítmica.
O(n) Complejidad lineal.
O(nlog n)
O(n2) Complejidad cuadrática.
O(n3) Complejidad cúbica.
O(nk) Complejidad polinómica.
O(2n) Complejidad exponencial.
35
![Page 36: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/36.jpg)
Complejidad de Algoritmos. Valores de crecimiento de las funciones.
n log n n n log n n2 n3 2n
1
2
4
8
16
32
0
1
2
3
4
5
1
2
4
8
16
32
0
2
8
24
64
160
1
4
16
64
256
1024
1
8
64
512
4096
32768
2
4
16
256
65536
2.147.483.648
36
![Page 37: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/37.jpg)
Complejidad de Algoritmos. Promedio de crecimiento de las funciones.
37
![Page 38: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/38.jpg)
Complejidad de Algoritmos. Cont.
O(log n), O(n) y O(n log n) crecen mas lentamente que los otros.
Para grandes conjuntos de datos, los algoritmos con una complejidad mayor que O(n3) son a menudo no aplicables.
Un algoritmo que es exponencial trabajara solamente con entradas muy pequeñas.
38
![Page 39: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/39.jpg)
Complejidad de Algoritmos. Ejemplo.
Paso Algoritmo Frecuencia 1
2
3
4
5
6
int minimo(int *vector, int n)
{
int i, min;
min = 1;
for (i = 2; i <= n; i++)
{
if (vector[i] < vector[min])
min = i;
}
return (vector[min]);
}
t(n) =
1
1
n
n-1
n-1
1
3n + 1
t(n) O(n).
39
![Page 40: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/40.jpg)
Complejidad de Algoritmos. Ejemplo.
Paso Algoritmo Frecuencia 1
2
3
4
5
6
7
void burbuja(int *vector, int n)
{
int i, j, aux;
for (i = 1; i <= n-1; i++)
for (j = i+1; j <= n; j++)
if (vector[i] > vector[j])
{
aux = vector[i];
vector[i] = vector[j];
vector[j] = aux;
}
}
t(n) =
1 n n n-1 n-1 n-1 n-1 n-1 n-1 n-1 n-1 n-1
5n2 - 8n + 5
t(n) O(n2). 40
![Page 41: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/41.jpg)
Complejidad de Algoritmos. Ejemplo.
Paso Algoritmo Frecuencia
1
2
3
4
5
void nuevo() {
int x, t;
x = 1; t = 0;
while (x < n) {
x = x * 2;
t = t + 1;
}
}
t(n) =
1
2
1 + log n
log n
log n
3 + 3 log n
t(n) O(log n).
41
![Page 42: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/42.jpg)
Complejidad de Algoritmos. Ejemplo. Cont.
Calculando el valor de t se tiene:
n t
1 0
2 1
4 2
8 3
16 4
32 5
Por lo tanto:
25 = 32
=> 2t = n
log2n = t
42
![Page 43: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/43.jpg)
Bibliografía
Fundamentos de Programación, Jorge Teran Pomier, 2006.
Fundamentals of Data Structures, Ellis Horowitz, 1981.
43
![Page 44: Análisis de Algoritmos1](https://reader030.fdocuments.es/reader030/viewer/2022032522/55cf8fed550346703ba16012/html5/thumbnails/44.jpg)
Taller de Programación
Gracias