1 / 12

Ingeniería en Software Facultad de Ingeniería Tecnológico de Antioquia Institución Universitaria

Análisis de Algoritmos 2. El concepto de complejidad ( aritmética en notación O) Prof.: Ricardo Botero Tabares. Ingeniería en Software Facultad de Ingeniería Tecnológico de Antioquia Institución Universitaria 2014. ANÁLISIS DE ALGORITMOS. 2. El concepto de complejidad

yagil
Télécharger la présentation

Ingeniería en Software Facultad de Ingeniería Tecnológico de Antioquia Institución Universitaria

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 Algoritmos2. El concepto de complejidad (aritmética en notación O)Prof.: Ricardo Botero Tabares Ingeniería en Software Facultad de Ingeniería Tecnológico de Antioquia Institución Universitaria 2014

  2. ANÁLISIS DE ALGORITMOS 2. El concepto de complejidad (aritmética en notación O) Para calcular el tiempo de ejecución de un algoritmo se debe definir su orden de magnitud, basado en el contador de frecuencias. El orden de magnitud hace referencia a la aritmética en notación O.

  3. Como se onotó antes, los órdenes de magnitud más comunes son los que se observan en la tabla inferior, donde los algoritmos más eficientes en cuanto a tiempo de ejecución son los de orden de magnitud constante, y los menos eficientes son los de orden de magnitud exponencial. Eficiencia Veamos otros algoritmos con orden de magnitud cúbico, logarítmico, semilogarítmico y exponencial.

  4. Algoritmo de complejidad cúbica No es difícil concebirlos: algoritmo con tres ciclos anidados. Ejemplo: llenar una arreglo de tres dimensiones. //Declaraciones previas: variables globales o de clase int n; doublecubo[] [] []; voidllenarCubo( ){ //Se asume que la variable entera n tiene un valor consistente. cubo = new double[n] [n] [n]; for (int i = 0; i < n; i++) for (int j= 0; j < n; j++) for (intk = 0; k < n; k++){ Consola.imprimir(“Digite un número real:”); cubo [i] [j] [k] = Consola.leerReal(); } } Orden de magnitud: O(n3)

  5. Algoritmo de complejidad logarítmica Recordemos el concepto de logaritmo: logb(x) = r El número r es el exponente al cual hay que elevar el número b (base) para obtener x, es decir: br = x Ejemplos: log2(32) = 5 porque 25= 32 log10(100) = 2 porque 102 = 100 En otras palabras: el logaritmo de un número x es el número de veces que hay que dividir dicho número, por otro llamado base (b), hasta obtener un cociente de uno (1).

  6. Un algoritmo clásico de complejidad logarítmica en base 2, es el algoritmo de la búsqueda binaria sobre un vector ordenado. vec El algoritmo es el siguiente: intbusquedaBinaria(intdato) { // El vector vec y su tamaño n // son atributos de clase intcentro, inf = 0, sup = n-1; while (inf <= sup){ centro = (sup + inf) / 2; if (vec[centro] == dato) returncentro; else if (dato < vec[centro]) sup = centro - 1; elseinf = centro + 1; } return-1; } ---------------------------------------------- 2 -------------------------------------------------------- log2(n) + 1 --------------------------------------- log2(n) --------------------- log2(n) -------- log2(n) ------------------------- log2(n) ------------------------------------------------------------------------log2(n) --------------------------------------------------------------- 1 ______________ 6log2(n) + 3

  7. Otros algoritmos sencillos de complejidad logarítmica i) O(log2(n)) void metodoLogaritmico1( ){ int n, cont, i; n = 32, cont = 0, i = 32; while (i > 1){ cont = cont + 1; i = i / 2; } Consola.imprimir(n + “\n” + cont); } O también:

  8. ii) O(log2(n)) void metodoLogaritmico2( ){ int n, cont, i; n = 32, cont = 0, i = 1; while (i < n){ cont = cont + 1; i = i * 2; } Consola.imprimir(n + “\n” + cont); }

  9. iii) O(log3(n)) void metodoLogaritmico3( ){ int n, cont, i; n = 81, cont = 0, i = 81; while (i > 1){ cont = cont + 1; i = i / 3; } Consola.imprimir(n + “\n” + cont); } En general, si la variable controladora del ciclo (en este caso i) se dividiera por x, el algoritmo sería O(logx(n)).

  10. Algoritmo de complejidad semilogarítmica Se debe tener un ciclo logarítmico dentro de otro ciclo de magnitud lineal. Ejemplo: voidsemiLogaritmico( int n){ intacum, i, j, tot; acum= 0, i = 1; while (i <= n){ tot = 0; j = n; while(j > 1){ tot = tot +1; j = j / 2; } Consola.imprimir(tot); acum = acum + tot; i = i + 1; } Consola.imprimir(n + “\n” + acum); } Orden de magnitud: nlog2(n)

  11. Búsqueda del algoritmo más eficiente Considérese el siguiente problema: Leer un entero positivo y mostrar la suma de los enteros desde uno (1) hasta el número ingresado. Una solución inmediata es la siguiente: voidsumatoria( ){ int n, suma = 0, i; Consola.imprimir(“Ingrese un número entero positivo:”); n = Consola.leerEntero( ); for (i = 1; i <= n; i++) suma += i; Consola.imprimir(“Suma enteros desde 1 hasta ” + n + “: ”+ suma); } Este método es: O(n)

  12. Ahora, existe una fórmula matemática para calcular la suma de los enteros entre 1 y una variable entera n: suma = = n*(n + 1) / 2 Aplicando esta fórmula, podemos solucionar el problema sin el uso de un ciclo en el cálculo de la sumatoria: voidsumatoriaConFormula( ){ int n, suma; Consola.imprimir(“Ingrese un número entero positivo:”); n = Consola.leerEntero( ); suma = n*(n + 1) / 2; Consola.imprimir(“Suma enteros desde 1 hasta ” + n + “: ”+ suma); } Este método es: O(1)

More Related