75.41 Algoritmos y Programación II Cátedra Ing. Patricia Calvo Complejidad algorítmica

Contenido Algoritmos Complejidad algorítmica Órdenes

Algoritmos

Un algoritmo es una secuencia finita de instrucciones. Cada una de las instrucción tiene un significado preciso y puede ejecutarse con una cantidad finita de esfuerzo en un tiempo finito.

Algoritmos Características Precisión ○ Expresado sin ambigüedad. Determinismo ○ Responde del mismo modo antes las mismas condiciones. Finito ○ Descripto con un conjunto limitado de pasos.

Algoritmos Medición ¿Podemos medir de alguna manera lo que tarda un algoritmo en resolver un problema de cierto tamaño? ¿Cómo podemos lograr que la medición sea independientes de factores como el lenguaje, el compilador o el ambiente de ejecución? ¿Habrá una forma de determinar si un algoritmo es “mejor” o “peor” que otro?

Algoritmos Eficiencia Atributo de calidad del software. La eficiencia de un módulo de software está dada por su capacidad para demandar pocos recursos de hardware ○ Tiempo de procesamiento ○ Memoria interna y externa ○ Ancho de banda en los medios de comunicación ○ etc.

Algoritmos Parámetros de la eficiencia El uso eficiente de los recursos suele medirse en función de dos parámetros: ○ espacio: memoria que utiliza ○ tiempo: lo que tarda en ejecutarse.

Complejidad algorítmica

La complejidad algorítmica representa la cantidad de recursos que necesita un algoritmo para resolver un problema y por tanto permite determinar la eficiencia de dicho algoritmo. Los criterios que se van a emplear para evaluar la complejidad algorítmica no proporcionan medidas absolutas sino medidas relativas al tamaño del problema.

Complejidad algorítmica Tamaño del problema Entendemos por tamaño del problema al número de elementos sobre los que se va a ejecutar el algoritmo. Por ejemplo, la dimensión del vector a ordenar o el tamaño de las matrices a multiplicar.

Complejidad algorítmica Eficiencia temporal Nos centraremos en la eficiencia temporal. El análisis de la eficiencia en el consumo de otros recursos se hace de manera análoga.

Complejidad algorítmica Medición temporal Denotaremos por T(n) el tiempo de ejecución de un algoritmo para una problema de tamaño n. La unidad de tiempo a la que debe hacer referencia estas medidas de eficiencia no puede ser expresada en segundos o en otra unidad de tiempo concreta. T(n) debe indicar el número de instrucciones ejecutadas.

Complejidad algorítmica Principio de invarianza Dado un algoritmo y dos implementaciones suyas I 1 e I 2, que tardan T 1 (n) y T 2 (n) respectivamente, existe una constante real c > 0 y un número natural n 0 tales que para todo n ≥ n0 se verifica que T1(n) ≤ cT2(n).

Órdenes

Orden del algoritmo Un algoritmo tarda un tiempo del orden de T(n) si existe una constante real c > 0 y una implementación I del algoritmo que tarda menos que cT(n), para todo n tamaño de la entrada.

Órdenes Casos Como el comportamiento de un algoritmo depende de otras características del problema además de su tamaño, se considera: ○ Peor caso ○ Mejor caso ○ Caso medio

Órdenes ¿Qué medimos? Medimos el número de operaciones elementales que componen el algoritmo. Operación elemental ○ Aquella que se realiza en tiempo acotado por una constante (independiente del problema). ○ Ejemplo: comparación, asignación, operaciones aritméticas, etc.

Órdenes Medición El tiempo de ejecución de un algoritmo va a ser una función que mide el número de operaciones elementales que realiza el algoritmo para un tamaño de problema dado.

Órdenes ¿Cómo medimos? Operación elemental ○ T = 1 Secuencia de instrucciones: S 1 ; S 2 ;...; S n ; ○ T = T(S 1 ) + T(S 2 ) T(S n ) Sentencia condicional: if ( C ) { S 1 } else { S 2 } ○ T = T(C) + max { T(S 1 ), T(S 2 ) } Setencia repetitiva: while ( C ) { S } ○ T = T(C) + n * T(S)

Ejemplos

Ejemplos Ejemplo 1 boolean esValido(int numero) { return (numero > 0); } boolean esValido(int numero) { return (numero > 0) || (numero < 0); } int procesar(int numero, boolean completo) { int resultado = numero; if (completo) { resultado = resultado * 2; } resultado = resultado % 5; return resultado; }

Ejemplos Ejemplo 2 void inicializar(int[] vector) { for (int i = 0; i < matriz.length; i++) { vector[i] = 0; } } void inicializar(int[] vector) { for (int i = 0; i < matriz.length; i++) { if ((i % 2) == 0) { vector[i] = 1; } else { vector[i] = 2; } } }

Ejemplos Ejemplo 3 void inicializar(int[][] matriz, int valor) { for (int i = 0; i < matriz.length; i++) { for (int j = 0; j < matriz[i].length; j++) { matriz[i][j] = valor; } } }

Ejemplos Ejemplo 4 void generarIdentidad(int[][] matriz) { for (int i = 0; i < matriz.length; i++) { for (int j = 0; j < matriz[i].length; j++) { if (i == j) { matriz[i][j] = 1; } else { matriz[i][j] = 0; } } } }

Ejemplos Ejemplo 5 void generarTriangularSuperior(int[][] matriz, int valor) { for (int i = 0; i < matriz.length; i++) { for (int j = i; j < matriz[i].length; j++) { matriz[i][j] = valor; } } }

Cotas

Órdenes Cotas de complejidad Lo que importa es el comportamiento asintótico de la eficiencia. Medida asintótica ○ Comportamiento del algoritmo cuando el tamaño del problema aumenta. Las cotas buscan definir clases de equivalencia, correspondientes a las funciones con el mismo comportamiento asintótico, es decir “crecen de la misma forma”.

Órdenes Cota superior Notación O ○ Dada una función f, queremos estudiar aquellas funciones g que a lo sumo crecen tan deprisa como f. ○ Al conjunto de tales funciones se le llama cota superior de f y lo denominamos O(f). ○ Conociendo la cota superior de un algoritmo podemos asegurar que, en ningún caso, el tiempo empleado será de un orden superior al de la cota.

Órdenes Cota inferior Notación Ω ○ Dada una función f, queremos estudiar aquellas funciones g que a lo sumo crecen tan lentamente como f. ○ Al conjunto de tales funciones se le llama cota inferior de f y lo denominamos Ω(f). ○ Conociendo la cota inferior de un algoritmo podemos asegurar que, en ningún caso, el tiempo empleado será de un orden inferior al de la cota.

Órdenes Orden exacto Notación Θ (Theta) ○ Conjuntos de funciones que crecen asintóticamente de la misma forma. ○ g ∈ Θ(f) indica que g está acotada tanto superior como inferiormente por múltiplos de f.

Órdenes Propiedades de O Para cualquier función f se tiene que f ∈ O(f) f ∈ O(g) ⇒ O(f) ⊂ O(g) O(f) = O(g) ⇔ f ∈ O(g) y g ∈ O(f) Si f ∈ O(g) y g ∈ O(h) ⇒ f ∈ O(h) Si f ∈ O(g) y f ∈ O(h) ⇒ f ∈ O(min(g,h))

Órdenes Propiedades de O (cont.) Regla de la suma ○ Si f 1 ∈ O(g) y f 2 ∈ O(h) ⇒ f 1 + f 2 ∈ O(max(g,h)) Regla del producto ○ Si f 1 ∈ O(g) y f 2 ∈ O(h) ⇒ f 1 * f 2 ∈ O(g*h) Si existe lim n →∞ (f(n) / g(n)) = k ○ si k ≠0 y k < ∞ entonces O(f) = O(g) ○ si k = 0 entonces f ∈ O(g), es decir, O(f) ⊂ O(g), pero sin embargo se verifica que g ∉ O(f)

Órdenes Jerarquía de órdenes Los comportamientos asintóticos de más frecuente aparición se pueden ordenar de menor a mayor crecimiento de la siguiente forma: ○ 1<<log n<<n<<n log n<<n 2 <<n 3 <<.....<<2 n <<n!

Gráficamente

Órdenes Ejemplos en la jerarquía PolinómicaO(n k ) k>3 IntratableAlgunos algoritmos de grafos ExponencialO(k n ) k>1 QuicksortCasi linealO(nlog n) TratableAlgoritmo de la burbujaCuadráticaO(n 2 ) Producto de matricesCúbicaO(n 3 ) Búsqueda lineal Búsqueda binaria No depende del tamaño del problema FactorialO(n!) LinealO(n) LogarítmicaO(log n) EficienteConstanteO(1)

Escala logarítmica en las ordenadas

Ejemplos

Ejemplos Selección int n = vector.length; for (int longitud = n; longitud vector[posicionMaximo]) { posicionMaximo = j; } } intercambiar(vector,posicionMaximo,longitud-1); }

Ejemplos Búsqueda binaria boolean encontrado = false; int primero = 0; int ultimo = vector.length – 1; while ((! encontrado) && (primero vector[central]) { primero = central + 1; } else { ultimo = central - 1; } } }

Ejemplos Quicksort public void ordenar(int[] vector, int primero, int ultimo) { int pivote = vector[(primero + ultimo) / 2]; int i = primero; int j = ultimo; do { while (vector[i] pivote) j--; if (i <= j) { this.intercambiar(vector, i, j); i++; j--; } } while (i <= j); if (primero < j) this.ordenar(vector, primero, j); if (i < ultimo) this.ordenar(vector, i, ultimo); }

Preguntas ¿Qué es la complejidad algorítmica? ¿Cómo se mide la complejidad algorítmica? ¿Qué factores de un algoritmo se pueden medir con la complejidad algorítmica?

Bibliografía [Guerequeta 1998] R. Guerequeta, A. V. Vallecillo, Técnicas de diseño de algoritmo, Servicio de Publicaciones de la Universidad de Málaga, 1998 ○ [Aho 1988] Aho, Alfred, Estructura de datos y algoritmos, Addison-Wesley, 1988

Fin