Aunque no es posible encontrar una frmula que siempre funcione para calcular la complejidad de un algoritmo, si es posible encontrar una

serie de pautas que nos permitirn de una manera lgica llegar a su clculo. Los algoritmos bien estructurados estn conformados por una combinacin de las siguientes instrucciones: a. Sentencias simples Se denominan sentencias simples, aquellas que tienen que ver con la asignacin, operaciones matemticas bsicas, entrada / salida, etc. siempre y cuando no trabajen sobre variables estructuradas cuyo tamao est relacionado con el tamao del problema (lectura o escritura de arreglos, archivos, puertos). La inmensa mayora de las sentencias simples de un algoritmo requieren un tiempo constante de ejecucin, siendo su complejidad O(1). Ejemplos: x=1 y=z+x+w; scanf(%d,&x); printf(%d,x); Cada una de las anteriores instrucciones de forma independiente tienen complejidad de O(1). b. Condicionales (if - else) Los condicionales suele ser O(1), a menos que estos involucren un llamado a un procedimiento, y siempre se le debe sumar la peor complejidad posible de las alternativas del condicional, bien en la rama afirmativa, o bien en la rama negativa. En decisiones mltiples (switch) se tomar la peor de todas las ramas. Ejemplos: If (a>b) { for (x=1; x<=n; x++) suma += x; } else { suma=0; } La parte cierta del condicional es un ciclo que se repite n veces, por lo tanto su complejidad es O(n), mientras que la parte negativa es una asignacin simple con complejidad O(1); por lo tanto la complejidad del condicional est dada por la mayor complejidad entre la parte afirmativa y la negativa del mismo, siendo entonces O(n) la complejidad total del condicional. c. Ciclos (while, for, do-while) En los ciclos con un contador explcito, se distinguen dos casos: que el tamao n forme parte de los lmites del ciclo, con una complejidad basada en n y dependiente de la forma como avanza el ciclo hacia su terminacin; si el ciclo se realiza un nmero constante de veces, independiente de n, entonces la repeticin slo introduce una constante multiplicativa que puede absorberse, dando como resultado O(1). Ejemplos: Si el ciclo es de tamao constante(k es un valor constante) For (i=0; i<k; i++) {

Sentencias simples } La complejidad es: k*O(1) ---> O(1) Si el tamao n aparece como el lmite de las iteraciones: For (i=0; i<n; i++) { Sentencias simples } La complejidad es: n * O(1) ----> O(n) O si los ciclos son anidados: For (i=0; i<n; i++) { For (j=0; j<n; j++) { Sentencias simples } } La complejidad es: n *n* O(1) ----> O(n2) Para ciclos anidados pero con variables dependientes: For (i=0; i<n; i++) { For (j=0; j<i; j++) { Sentencias simples } } Teniendo en cuenta que el bucle exterior se realiza n veces, mientras que el interior se realiza primero una, luego dos, despus tres y as hasta n.: 1 + 2 + 3 + ... + n = n*(n+1)/2 ----> la complejidad es : O(n2) A veces aparecen ciclos multiplicativos, donde la evolucin de la variable de control no es lineal (como en los casos anteriores) c= 1; while(c <n) { c= 2 * c; } El valor inicial de la variable c es 1, llegando a 2n al cabo de n - iteraciones. El nmero de iteraciones es tal que 2k >= n >= k (log2 (n)) y, por tanto, la complejidad del ciclo es O(log2 n). El siguiente es un ejemplo en el cual la variable se divide cada vez a la mitad: c= n; while(c > 1) { c= c / 2;

} Un razonamiento anlogo nos lleva a log2n iteraciones y, por tanto, a un orden O(log2 n) de complejidad. Y la combinacin de los anteriores: for (i=0; i<n; i++) { c=i; while (c>0) { c=c/2; } } Se tiene un bucle interno de orden O(log2 n) que se ejecuta n veces en el ciclo externo; luego el ejemplo es de orden O(n log2n) d. Llamadas a procedimientos La complejidad de llamar a un procedimiento viene dada por la complejidad del contenido del procedimiento en s. El costo del llamado es una constante que podemos obviar inmediatamente dentro de nuestro anlisis. El clculo de la complejidad asociada a un procedimiento puede complicarse si se trata de procedimientos recursivos, los cuales requieren de un proceso ms detallado y complejo. Ejemplos: Si hay varias instrucciones y entre ellas un llamado a una funcin. for (i=0; i<n; i++) { insertar(arreglo, i); } Hay un ciclo que se realiza n veces, lo que generara un complejidad de O(n), pero como en su interior hay un llamado a la funcin insertar, la complejidad del ciclo estar multiplicada por la complejidad de la funcin insertar. Si hay dos o ms llamados a funciones. ordenar(arreglo, n); mostrar(arreglo, n) Suponiendo que ordenar organiza un vector mediante el mtodo rpido (Quick-Sort) con una complejidad de O(n log2 n), y que mostrar simplemente presenta el contenido del arreglo en la pantalla con una complejidad de O(n). La complejidad total ser la mayor de los dos llamados a las funciones, resultando O(n log2 n). e. Secuencias de instrucciones La complejidad de una serie de instrucciones de un programa es del orden de la suma de las complejidades individuales, aplicndose las operaciones antes expuestas. Ejemplos: Veamos el anlisis de un simple enunciado de asignacin a una variable entera: a = b; Como el enunciado de asignacin toma tiempo constante, est en O(1). Consideremos un simple ciclo for:

sum=0; for(i=1; i<=n; i++) sum += n; La primera lnea es de complejidad constante O(1). El ciclo for es repetido n veces. La tercera lnea toma tambin un tiempo constante, por la regla de simplificacin (4), el costo total por ejecutar las dos lneas que forman el ciclo for es O(n). Por la regla (3), el costo del fragmento de cdigo es tambin O(n). Analicemos un fragmento de cdigo con varios ciclos for, dos de los cuales estn anidados. sum=0; for(j=1; j<=n; j++) for(i=1; i<=j; i++) sum++; for(k=1; k<=n; k++) A[k]= k-1; Este cdigo tiene tres partes: una asignacin, y dos ciclos. La asignacin toma tiempo constante, llammosla c1. El segundo ciclo es similar al ejemplo anterior y toma c2n= O(n). Analicemos ahora el primer ciclo, que es un doble ciclo anidado. En este caso trabajemos de adentro hacia fuera. La expresin sum++ requiere tiempo constante, se le llamar c3. Como el ciclo interno es ejecutado j veces, por la regla (4), tiene un costo de c3* j. El ciclo exterior es ejecutado n veces, pero cada vez el costo del ciclo interior es diferente. El costo total del ciclo es: c3 veces la suma de los nmeros del 1 al n, es decir La suma de 1,2,,,, n == n(n+1)/2, que es una complejidad de O(n2). Por la regla (3), O(c1+c2n+c3n2) es simplemente O(n2). Comparemos el anlisis de los siguientes fragmentos de cdigo: sum1=0; for(i=1; i<=n; i++) for(j=1; j<=n; j++) sum1++; sum2=0; for(i=1; i<=n; i++) for(j=1; j<=i; j++) sum2++; El primer fragmento ejecuta la instruccin sum1++n2 veces, por otra parte, el segundo fragmento de cdigo tiene un costo aproximado de n2. As ambos cdigos tienen un costo de O(n2). Es bueno analizar el siguiente ejemplo en el cual se aprecia que no siempre los ciclos anidados tienen complejidad O(n2): sum1=0; for(k=1; k<=n; k*=2) for(j=1; j<=n; j++) sum1++; Como el primer ciclo se realiza log2 n veces y el interno n veces, entonces el algoritmo tiene un costo de O(n log n).