1 / 12

Análisis de Algoritmos Tiempo de ejecución de un algoritmo Prof.: Ricardo Botero Tabares

Análisis de Algoritmos Tiempo de ejecución de un algoritmo Prof.: Ricardo Botero Tabares. Ingeniería en Software Facultad de Ingeniería Tecnológico de Antioquia Institución Universitaria 2014. ANÁLISIS DE ALGORITMOS. Tiempo de ejecución de un algoritmo

dani
Download Presentation

Análisis de Algoritmos Tiempo de ejecución de un algoritmo Prof.: Ricardo Botero Tabares

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Análisis de AlgoritmosTiempo de ejecución de un algoritmoProf.: Ricardo Botero Tabares Ingeniería en Software Facultad de Ingeniería Tecnológico de Antioquia Institución Universitaria 2014

  2. ANÁLISIS DE ALGORITMOS • Tiempo de ejecución de un algoritmo Al evaluar un algoritmo se debe tener en cuenta su eficiencia en cuanto a: • consumo de memoria y • tiempo de ejecución, teniendo en cuenta el tamaño de la entrada de datos.

  3. La eficiencia en cuanto al consumo de memoria: hoy es irrelevante. La eficiencia en cuanto al tiempo de ejecución es relevante (a pesar de las altas velocidades del procesador), sobre todo en algoritmos relacionados con el control de procesos en tiempo real y en aquellos cuya frecuencia de ejecución es alta.

  4. ¿Cómo medir el tiempo de ejecución de un algoritmo? Existen dos formas: a posteriori y a priori . • A posteriori Solución del problema (Identificación de requisitos, abstracción de clases, definición de las responsabilidades de las clases, escritura de seudocódigo OO), edición/compilación/ejecución del programa en una máquina y lenguaje determinado (aplicando pruebas continuas o paralelas).  Se evalúa la calidad del compilador y de la máquina, pero no la del algoritmo.

  5. A priori La evaluación del algoritmo se realiza con independencia del lenguaje de programación en el cual se codifique y de la máquina en la cual se ejecute. Para ello se deben definir dos conceptos básicos: Contador de frecuencias y orden de magnitud. Contador de Frecuencias: es una expresión algebraica que indica el número de veces que se ejecutan las instrucciones de un algoritmo.

  6. Ejemplos: Algoritmo 1: void metodo1(){ int a, b, c; double d; Consola.imprimir(“Ingrese dos números enteros:”); a = Consola.leerEntero(); b = Consola.leerEntero(); c = a + b; d = (c % a) / 7; Consola.imprimir (“Suma de ambos números: ” + c); Consola.imprimir (“(” + c + “ % ” + a + “) / 7 = ” + d); } -------------- 1 ---------------------------------------------------- 1 ---------------------------------------------------- 1 ----------------------------------------------------------------------- 1 ------------------------------------------------------------------- 1 ------------ 1 ----------- 1 _____ 7 Contador de frecuencias

  7. Ejemplos (cont): Algoritmo 2: void metodo2(){ intacum, cont, n; Consola.imprimir(“Ingrese un número entero:”); n = Consola.leerEntero(); suma = 0; cont = 1; while (cont <= n){ suma = suma + cont; cont = cont + 1; } Consola.imprimir(“Contador = ” + cont + “\nAcumulador = ” + suma); } --------------------------- 1 ---------------------------------------------------------- 1 ------------------------------------------------------------------------- 1 ------------------------------------------------------------------------- 1 -------------------------------------------------------------- n + 1 --------------------------------------------------- n ---------------------------------------------------------- n ------------------------------------------------------------------------ n  1 _____ 4n + 6 Contador de frecuencias

  8. Ejemplos (cont): Algoritmo 3: voidmetodo3(int n, int m){ intacum = 0, i = 1, j, cont; while (i <= n){ cont = 0; j = 1; while (j <= m){ cont = cont + 1; j = j + 1; } acum = acum + cont; i = i + 1; } Consola.imprimir(n + “\n” + m + “\n” + acum); } --------------------------------------------- 2 ----------------------------------------------------------- n + 1 ------------------------------------------------------ n ------------------------------------------------------------- n ----------------------------------------------- (m +1) * n ------------------------------- m * n ------------------------------------------- m * n --------------------------------------------------------------- m * n --------------------------------------- n --------------------------------------------------------- n --------------------------------------------------------------- n ------------------ 1 ________________ 4 (n * m)+ 7n + 4 Contador de frecuencias

  9. Ejemplos (cont): Algoritmo 4: voidmetodo4(int n){ int sum = 0, i = 1, tot, j; while (i <= n){ tot = 0; j = 1; while (j <= n){ tot = tot + 1; j = j + 1; } sum = sum + tot; i = i + 1; } Consola.imprimir(n + “\n” + sum); } ---------------------------------------------- 2 ----------------------------------------------------------- n + 1 ------------------------------------------------------ n ------------------------------------------------------------- n ----------------------------------------------- (n +1) * n ------------------------------- n2 ------------------------------------------- n2 -------------------------------------------------------------- n2 --------------------------------------- n --------------------------------------------------------- n --------------------------------------------------------------- n ------------------------------------ 1 ________________ 4n2+ 7n + 4 Contador de frecuencias

  10. Orden de magnitud: El orden de magnitud define la eficiencia de un algoritmo en cuanto al tiempo de ejecución. Se obtiene a partir del contador de frecuencias, así: De los términos resultantes, se eliminan los coeficientes, las constantes y los términos negativos; si los términos son dependientes entre sí, se elije el mayor de ellos. Si el contador de frecuencias es una constante, el orden de magnitud es O(1), es decir, constante.

  11. Teniendo en cuenta lo anterior, los órdenes de magnitud de los algoritmos dados son: • Algoritmo 1: O(1) • Algoritmo 2: O(n) • Algoritmo 3: O(n * m) • Algoritmo 4: O(n2)

  12. Órdenes de magnitud comunes

More Related