Tema 2 eficiencia_y_complejidad_grupo_21
-
Upload
carlos-a-iglesias -
Category
Technology
-
view
1.041 -
download
1
description
Transcript of Tema 2 eficiencia_y_complejidad_grupo_21
![Page 1: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/1.jpg)
Análisis y Diseño de Software
Departamento de Ingeniería de Sistemas Telemáticoshttp://moodle.dit.upm.es
Tema 2b. Eficiencia y Complejidad
Carlos A. Iglesias <[email protected]>
G21
![Page 2: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/2.jpg)
Eficiencia y Complejidad 2
Teoría
Ejercicio práctico en el ordenador / Problema
Ampliación de conocimientos
Lectura / Vídeo / Podcast
Práctica libre / Experimentación
Legenda
![Page 3: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/3.jpg)
Eficiencia y Complejidad 3
Bibliografía
● Eficiencia algorítmica– http://en.wikipedia.org/wiki/Algorithmic_efficien
cy – http://en.wikipedia.org/wiki/Analysis_of_algorith
ms#Shortcomings_of_empirical_metrics● http://jungla.dit.upm.es/~pepe/doc/adsw/Complejidad.pdf
![Page 4: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/4.jpg)
Eficiencia y Complejidad 4
Temario
● Complejidad: el problema
● Espacio de problemas
● Notación O (Big O)
● Complejidad de algoritmos básicos de ordenación y búsqueda
● Evaluar la complejidad de un algoritmo
● Análisis y conclusiones
![Page 5: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/5.jpg)
Eficiencia y Complejidad 5
Objetivos
● Entender cómo se pueden comparar algoritmos
● Entender qué es una medida de complejidad
● Conocer la notación O
● Conocer la notación O para algoritmos básicos de ordenación y búsqueda
● Saber razonar con la notación O
![Page 6: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/6.jpg)
Eficiencia y Complejidad 6
El problema
● ¿En qué nos basamos para seleccionar un algoritmo cuando hay tantos disponibles (y tan parecidos)?
![Page 7: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/7.jpg)
Eficiencia y Complejidad 7
● “En casi todos los cálculos, es posible una gran variedad en la forma de de llevar a cabo los procesos de computación. […] Es esencial seleccionar la forma que reduzca al mínimo el tiempo para completar un cálculo”
Ada Lovelace
¿Qué elegir?
![Page 8: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/8.jpg)
Eficiencia y Complejidad 8
¿Qué elegir?
● El algoritmo más eficiente
● Eficiencia: inversamente proporcional a los recursos (memoria, tiempo, …) consumidos por un algoritmo
![Page 9: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/9.jpg)
Eficiencia y Complejidad 9
Formas de seleccionar
● De forma 'empírica':– Medimos su recursos consumidos de los
algoritmos (tiempo, memoria, uso de comunicaciones, disco, consumo energético, …, caso mejor, peor, medio, …)
● De forma 'analítica' / teórica:– Calculamos un 'límite' de estos recursos,
analizando el algoritmo y su implementación
![Page 10: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/10.jpg)
Eficiencia y Complejidad 10
Medidas empíricas
● Medimos (p.ej. Tiempo).
// Creo el entornoAlgoritmo a = new Algoritmo();Datos d = new Datos(); // relleno
// Midolong t1 = System.currentTimeMillis();a.run(d);long t2 = System.currentTimeMillis();long duracion = t2 – 1;
![Page 11: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/11.jpg)
Eficiencia y Complejidad 11
Medidas empíricas● Como los algoritmos son genéricos, las medidas empíricas pueden
verse afectadas por:
– El lenguaje de programación
– El entorno de ejecución / sistema operativo (p.ej. JVM GC, multinúcleo, …)
– Los datos que usemos al medir
● Pueden ayudarnos a entender cómo funcionan, y tenemos que analizar bien el experimento cuando obtenemos resultados inesperados
● Si medimos, podemos intentar ajustar las gráficas, y ver qué distribución siguen (polinómico, lineal, etc.). Si estás interesado, mira los apuntes.
![Page 12: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/12.jpg)
Eficiencia y Complejidad 12
Medidas teóricas: notación O (Big O Notation)
● Nos ayuda a clasificar algoritmos según cómo crezca su respuesta (tiempo de ejecución, memoria, etc.) con el número de datos de entrada
● Algoritmos con la misma “respuesta”, tendrán la misma notación O
● Representa la cota del valor peor que pueden tomar, el límite superior
![Page 13: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/13.jpg)
Eficiencia y Complejidad 13
Órdenes de funciones comunes
Notación Nombre Comentario
O(1) Constante Ideal
O(log n) Logarítmico Muy bueno
O(n) Lineal normal
O(nlogn) Lineal logarítmico
razonable
O(n2) Cuadrático tratable
O(nc) Potencial “tratable”
O(cn), n >1 Exponencial No es práctico
O(n!) Factorial inviable
![Page 14: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/14.jpg)
Eficiencia y Complejidad 14
Orden
![Page 15: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/15.jpg)
Eficiencia y Complejidad 15
O(1): complejidad constante
● Complejidad constante, independiente del tamaño de la entrada
boolean isElementoNulo(Object [] array, int indice) { if (a[indice] == null) {
return true; } return false;}
boolean isElementoNulo(Object [] array, int indice) { return (a[indice] == null) {}
![Page 16: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/16.jpg)
Eficiencia y Complejidad 16
O(n): lineal
● Consumo de recursos directamente proporcional a la entrada
● Ej. búsqueda lineal. Caso peor: buscamos el último elemento, recorremos n → O(n)
![Page 17: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/17.jpg)
Eficiencia y Complejidad 17
Burbuja – notación O
● Si analizamos cuántas comparaciones hacemos
● P. ej para n = 10– 10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 = 45
● En general, para N:– (N – 1) + (N – 2) + … + 1 = N * (N-1)/2
● Si N es grande, el número será N2
● La notación O : O(N2), cota superior asintótica
![Page 18: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/18.jpg)
Eficiencia y Complejidad 18
Burbuja: Complejidad intercambios
● Si analizamos intercambios, si suponemos que el conjunto es aleatorio, podemos suponer que sólo estarán desordenados la mitad– Si había N2/2 comparaciones, habría N2/4
intercambios
● Tanto comparaciones como intercambios son O(N2)
![Page 19: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/19.jpg)
Eficiencia y Complejidad 19
Selección: Análisis
● Complejidad:
– Hacemos las mismas comparaciones que en la burbuja: N * (N – 1) /2 → O(N2)
– Hacemos menos intercambios, menos que N (una pasada) → O(N)
● Para grandes valores de N, pesará más el término de comparaciones, y la complejidad será O(N2)
● Para N pequeño, será más rápido que la burbuja
● En general: no es un algoritmo adecuado
● Puede ser bueno si los tiempos de intercambio son altos
![Page 20: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/20.jpg)
Eficiencia y Complejidad 20
Inserción: análisis
● Complejidad: – En la primera pasada, comparamos con 1 carta, en la
segunda con 2, en la tercera con 3, … → 1 + 2 + 3 + … + N – 1 = N * (N – 1) / 2
– En media, compararemos con la mitad de cartas ordenadas → N * (N – 1) / 4 → O(N2)
– Número de copias similar al de comparaciones, pero una copia requiere menos tiempo que un intercambio
– Si los datos ya están ordenados (o casi), sería O(N)
![Page 21: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/21.jpg)
Eficiencia y Complejidad 21
Quicksort: Análisis
● Complejidad:– En la mayor parte de los casos es el más
rápido: O(n * log(n))
![Page 22: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/22.jpg)
Eficiencia y Complejidad 22
Análisis complejidad
Mejor Medio PeorSelección O (n2) O (n2) O (n2)Inserción O (n) O (n2) O (n2)
Burbuja O (n) O (n2) O (n2)Quick sort O (n log n) O (n log n) O (n2)
![Page 23: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/23.jpg)
Eficiencia y Complejidad 23
¿Cómo calculamos la complejidad? (I)
●Analizamos el código
● En sentencias condicionales (if/else-switch), cogemos la rama 'peor'
●Bucles:– Si el bucle no depende de n, simplemente es una cte
O(1), que quitamos
– Si el bucle depende de n, tendremos O(n)
– Si tenemos bucles anidados, que dependen de n, si son dos, tenemos O(n2) (nos sale 1 + 2 + .. = n(n-1)/2)
![Page 24: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/24.jpg)
Eficiencia y Complejidad 24
¿Cómo calculamos la complejidad? (II)
●Si el bucle es multiplicativo, es decir, no es lineal con n:
int c = 1;while (c < n) {
sentencias O(1);c *= 2;
}
Para n = 10:c= 1, c = 2, c = 4, c= 8En general, vale 2k <= n→ k = n * log2(n) → log(n)
int c = n;while (c > 1) {
sentencias O(1);c /= 2;
}
Para n = 10:c= 10, c = 5, c = 2, c= 1 → log(n)
![Page 25: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/25.jpg)
Eficiencia y Complejidad 25
¿Cómo calculamos la complejidad? (II)
●Si combinamos, nos sale O(nlogn):for (int i = 0; i < n; i++) { int c = i; while (c > 0) {
sentencias O(1);c /= 2;
}}
![Page 26: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/26.jpg)
Eficiencia y Complejidad 26
● Tiempo en ms, en Pentium 100 con 16MRam
Comparación
N selección inserción burbuja QuickSort Quick + Insert1 0 0 0 0 02 0 0 0 0 05 0 0 0 0 0
10 0 0 0 0 020 0 0 0 0 050 0 0 6 0 0
100 5 0 11 0 0200 22 11 39 0 6500 109 61 236 11 11
1.000 417 253 956 27 282.000 1.654 1.005 3.817 55 555.000 10.309 6.207 23.898 165 159
10.000 41.375 24.816 96.042 352 33620.000 165.710 99.152 381.415 807 758
![Page 27: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/27.jpg)
Eficiencia y Complejidad 27
Comparación
050.000
100.000150.000
200.000250.000
300.000350.000
400.000450.000
100
200
500
1.00
02.
000
5.00
0
10.0
00
20.0
00
L
T (
ms
)
burbuja
selección
inserción
QuickSort
Quick + Insert
![Page 28: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/28.jpg)
Eficiencia y Complejidad 28
Caso mejorN selección inserción burbuja QuickSort Quick + Insert
1 0 0 0 0 02 0 0 0 0 05 0 0 0 0 0
10 0 0 0 0 020 0 0 0 0 050 0 0 0 0 0
100 6 0 0 0 0200 17 0 0 0 0500 115 0 0 6 5
1.000 473 0 0 17 162.000 1.890 0 0 39 275.000 11.820 6 11 109 83
10.000 47.428 22 11 242 18120.000 189.140 39 27 522 390
![Page 29: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/29.jpg)
Eficiencia y Complejidad 29
Caso mejor
100
500
2.00
0
10.0
00
inserción
Quick + Insert0
200
400
600
T (m
s)
L
inserción
burbuja
Quick + Insert
QuickSort
![Page 30: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/30.jpg)
Eficiencia y Complejidad 30
Tipos de problemas
● Hay muchos problemas que no sabemos un algoritmo para resolverlos.
● Entre los que sabemos resolver, los tipos más importantes son:– Problemas P: Problemas con complejidad
polinómica (O(n), O(n2), etc.)– Problemas NP: Problemas que no pueden
resolverse en un tiempo polinómico, e intentamos buscar otro algoritmo.
![Page 31: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/31.jpg)
Eficiencia y Complejidad 31
Resumen
● Para elegir un algoritmo, podemos– Seguir un enfoque empírico, y ver cómo
evolucionan la respuesta del algoritmo con la entrada
– Seguir un enfoque analítico
● La notación O nos facilita razonar sobre la eficiencia de un algoritmo
![Page 32: Tema 2 eficiencia_y_complejidad_grupo_21](https://reader034.fdocuments.ec/reader034/viewer/2022052602/559d8c721a28abf40c8b46bc/html5/thumbnails/32.jpg)
Eficiencia y Complejidad 32
Preguntas
● Si pruebo dos algoritmos en mi ordenador, y uno tarda 10 segundos y otro 20 segundos, ¿cuál es más eficiente?
● Si sé que un algoritmo tiene una respuesta 9n3 + 2n2 + 4n +2, ¿cuál sería su notación O?
● ¿Qué significa que O es el límite asintótico?
● Si tienes unos algoritmos A, B, C con complejidad O(n), O(nlogn) y O(n2), ¿en qué orden los escogerías?
● Para cualquier valor de n, será siempre más rápido un algoritmo O(n)) que uno con O(n2)