La eficiencia de los programas

Jordi Linares Pellicer

EPSA-DSIC

ndice General
1

Introduccin .......................................................................................................................... 2

El coste temporal y espacial de los programas.................................................................... 2

2.1

El coste temporal medido en funcin de tiempos de las operaciones elementales .... 2

2.2

El coste como una funcin del tamao del problema .................................................. 3

2.3

La funcin de coste temporal definida por conteo de pasos ....................................... 4

Complejidad asinttica.......................................................................................................... 4
3.1

Comparacin de los costes de los algoritmos ............................................................. 4

3.2

Uso de la notacin asinttica ....................................................................................... 6

3.2.1

Anlisis por casos.................................................................................................... 6

3.2.2

Notacin asinttica en el mejor y peor caso............................................................ 6

3.3

Reglas generales ......................................................................................................... 6

3.3.1

Anlisis del coste de los algoritmos iterativos ......................................................... 7

3.3.2

Anlisis del coste de los algoritmos recursivos ....................................................... 7

1 Introduccin
Habitualmente se dispone de varios programas que resuelven un mismo problema. Para decidir
cul es el mejor, un criterio objetivo de comparacin es el de eficiencia: el programa ms
eficiente, el mejor, ser aquel que menos recursos requiera para su ejecucin. Visto que los
recursos bsicos de un ordenador son la memoria y el tiempo de CPU, la eficiencia de un
programa se expresa en trminos de:

su coste espacial o medida del espacio que ocupa en memoria a lo largo de su

ejecucin; sera la suma de los tamaos de todas las variables que implcita o
explcitamente se utilizan.

su coste temporal o una medida del tiempo empleado por ste para ejecutarse y dar
un resultado a partir de los datos de entrada.

A partir de estas definiciones, los costes de un programa concreto dependen de dos tipos de
factores. A saber,
1. Factores propios del programa utilizado, como son su estrategia de resolucin o los tipos
de datos que emplea.
2. Factores que dependen del entorno de programacin donde se vaya a ejecutar el
programa, como son el tipo de computador, el lenguaje de programacin utilizado, el
compilador que se utiliza, la carga del sistema, etc.
Por tanto, se pueden seguir dos aproximaciones para establecer el coste de un programa dado:
1. Anlisis terico o a priori: clculo del coste en funcin de los factores propios del
programa, y por lo tanto, independiente del entorno de programacin.
2. Anlisis experimental o a posteriori: medida del tiempo, en segundos, y memoria, en
bytes, empleados en la ejecucin del programa:

en un entorno de programacin determinado y

para un conjunto de datos de entrada adecuado.

Es importante recalcar que ambos tipos de anlisis son complementarios, y no excluyentes;

realizar un anlisis terico de su coste evita en ocasiones implementaciones tan laboriosas
como intiles. Ms an, la eficiencia es un criterio a incorporar en la estrategia de diseo de un
programa; independientemente del entorno donde se ejecute, un programa debe ser eficiente.
En lo que resta nos centraremos exclusivamente en el estudio del coste temporal y espacial
a priori de los programas.

2 El coste temporal y espacial de los programas

2.1 El coste temporal medido en funcin de los tiempos de las
operaciones elementales
Supongamos que se dispone de los siguientes algoritmos para calcular n*n, y el resultado
dejarlo sobre la variable m:

Algoritmo A1:
m n*n;

Algoritmo A2:
m 0;
desde i 1 hasta n hacer
m m+n;
fin_desde

Algoritmo A3:
m 0;
desde i 1 hasta n hacer
desde j 1 hasta n hacer
m m+1;
fin_desde
fin_desde

Si se define el coste temporal de un algoritmo como la suma de los costes de las operaciones
que implica, tenemos los costes siguientes:

Coste del algoritmo A1: TA1 = ta + top

donde ta es el coste de la operacin de asignacin y top es el coste de una operacin
aritmtica, en concreto de una multiplicacin.

Coste del algoritmo A2: TA2 = ta + ta + (n+1) * tc + n * ta + 2 * n * top

donde tc es el coste de la comparacin y top es en este caso el coste de la suma.

Coste del algoritmo A3: TA3 = ta + ta + (n+1) * tc + n * ta + n * (n+1) * tc + n2 * ta + 2 * n2

*top + n * top

Si queremos comparar los costes de estos algoritmos resulta bastante difcil, ya que los
tiempos de las operaciones pueden variar significativamente en funcin del entorno de
programacin utilizado; por otra parte, el estudio de costes as planteado requiere un
considerable esfuerzo de conteo. Una primera simplificacin consiste en independizar las
funciones de coste de los tiempos de ejecucin de las operaciones elementales. De esta forma,
las funciones de coste anteriores quedaran:

Coste del algoritmo A1: TA1 = k1

de esta forma estamos indicando que el coste del algoritmo A1 es constante,
independiente de n.

Coste del algoritmo A2: TA2 = k2 * n + k3

de esta forma indicamos que el coste del algoritmo va a depender de n de una forma
lineal.

Coste del algoritmo A3: TA3 = k4 * n2 + k5 * n + k6

de esta forma indicamos que el coste del algoritmo va a depender de forma cuadrtica
de n.

2.2 El coste como una funcin del tamao del problema

El coste temporal (espacial) de un algoritmo se define como una funcin no decreciente de la
cantidad de tiempo (espacio) necesario que el algoritmo necesita para realizarse en funcin del
tamao del problema.
El tiempo necesario para ejecutar un algoritmo depende casi siempre de la cantidad de datos
que tiene que procesar; es de esperar que, por ejemplo, ordenar 10.000 elementos requiera
ms tiempo que ordenar 10.
La talla o tamao de un problema se define precisamente como el valor o conjunto de valores
asociados a la entrada de un problema que representan una medida de la dificultad de su
resolucin. Por ejemplo, el nmero de elementos de un vector que se desea ordenar, el valor
del nmero del que quiere calcularse su factorial, etc.
A partir de ahora, se notar el coste temporal de un algoritmo A como TA(talla); por ejemplo, el
coste del algoritmo A2 se expresar como TA2(n).

2.3 La funcin de coste temporal definida por conteo de pasos

Se define un paso de programa como cualquier secuencia de operaciones con significado,
cuyo coste sea independiente del tamao del problema. Un paso se puede considerar como
una unidad de tiempo vlida para expresar el coste de un algoritmo. A partir de esta definicin
se puede calcular el coste de un algoritmo como el nmero de pasos de programa que realiza.
De esta forma, se independiza el anlisis de costes del tiempo de las operaciones elementales.
Utilizando esta definicin, los costes de los algoritmos anteriores seran:

Coste del algoritmo A1: TA1(n) = 1 paso

Coste del algoritmo A2: TA2 (n) = n + 2 pasos

Coste del algoritmo A3: TA3 (n) = n2 + n + 2 pasos

La decisin sobre qu es un paso en un determinado algoritmo o programa no es nica; en

cualquier caso, la nica diferencia que podra haber entre diferentes anlisis por pasos seran
constantes multiplicativas o aditivas. En el apartado siguiente veremos cmo estas diferencias
no tienen importancia en el estudio que se propone.

3 Complejidad asinttica
3.1 Comparacin de los costes de los algoritmos
El coste de un algoritmo se expresa como una funcin T(n) no decreciente de la talla del
problema. Por lo tanto comparar costes es comparar funciones no decrecientes de las que nos
interesa slo su tasa de crecimiento. Por ejemplo, si T(n) es un polinomio, entonces el
monomio de mayor grado del mismo es el que da el aspecto de la curva de crecimiento.
En la siguiente tabla se muestran, en orden creciente de tasa de crecimiento, distintas
funciones que describen comnmente el tiempo de ejecucin de los algoritmos.
Funcin

Nombre

constante

logn

logartmica

log n

logartmica al cuadrado

lineal

nlogn

nlogn

cuadrtica

cbica

exponencial

Supongamos que se est descargando un fichero de Internet, de forma que hay un retraso
inicial de 2 seg. para establecer la conexin y despus la descarga se realiza a razn de 1.6
kbytes/seg. Si el tamao del fichero es de N kbytes, el tiempo de descarga viene descrito por la
frmula lineal:

La descarga de un fichero de 80 kbytes requiere 52 seg., la descarga de un fichero el doble de

grande requiere del orden de 102 seg, es decir casi el doble. Esta propiedad, por la cual el
tiempo de ejecucin es esencialmente proporcional al tamao de la entrada, caracteriza a un
algoritmo lineal. Como puede verse en las grficas que se presentan a continuacin, las curvas
no lineales conducen a tiempos de ejecucin mayores. Esto indica que el coste lineal es, de
entre todos los que se muestran en estas grficas, el ms favorable.

Una funcin cbica es una funcin cuyo trmino dominante es n3 multiplicado por alguna
constante. Una funcin cuadrtica tiene como trmino dominante n2 por alguna constante, y
una funcin lineal tiene como trmino dominante n por alguna constante. El trmino dominante
de la funcin nlogn es n veces el logaritmo de n; la funcin logaritmo crece muy lentamente,
ms lentamente que cualquier raz.
En las figuras siguientes se presentan cuatro funciones tpicas en el anlisis de algoritmos:
lineal, nlogn, cuadrtico y cbico, sobre distintos tamaos del problema, la primera desde 1
hasta 100 y la segunda desde 1.000 hasta 10.000.

3.2 Uso de la notacin asinttica

Cuando se analiza el coste de un algoritmo, el objetivo es conocer sobre qu curva de coste se
encuentra dicho algoritmo. Tambin es necesario poder comparar estas curvas de costes con
el fin de poder decidir si un determinado algoritmo es mejor, peor o equivalente a otro. Es por
esto que lo que nos interesa es medir el ndice de crecimiento de las funciones de coste y
expresarlo en notacin asinttica. Tres razones apoyan esta decisin:

Para valores de n suficientemente grandes el valor de la funcin est completamente

determinado por el trmino dominante.

El valor exacto del coeficiente del trmino dominante no se conserva al cambiar de

entorno de programacin.

El uso de la notacin asinttica nos permite establecer un orden relativo entre

funciones comparando trminos dominantes.

3.2.1 Anlisis por casos

Como ya se ha comentado, el coste de un algoritmo es una funcin no decreciente de la talla
del problema. Adems, para un tamao fijo del mismo, el coste del algoritmo puede depender
de la configuracin de la entrada del problema, de lo que llamaremos instancia del problema.
Una instancia de un problema representa todas las configuraciones diferentes de la entrada, de
una talla determinada, para las que el comportamiento del algoritmo es el mismo en cuanto a
costes.
Cuando en el coste de un algoritmo se detectan instancias, a partir de las instancias
significativas se definen los siguientes conceptos:

Coste del algoritmo en el caso peor: es la complejidad del mismo para la instancia del
problema que presente el coste mayor.

Coste del algoritmo en el caso mejor: es la complejidad del mismo para la instancia del
problema que presente el coste menor.

Coste promedio del algoritmo: a la media de los costes de todas las instancias del
problema.

En general, el estudio del coste promedio de los algoritmos es difcil de realizar, tanto analtica
como experimentalmente, la principal dificultad reside en conocer la distribucin de
probabilidad sobre las instancias del problema.

3.2.2 Notacin asinttica en el mejor y peor caso

Diremos que el coste de un algoritmo T(n) pertenece a O(g(n)) cuando T(n) no superar,
para grandes tallas, un mltiplo de g(n). En otras palabras, T(n) no crece asintticamente
ms rpido que g(n), es decir, g(n) por una constante es una cota superior de T(n).

Diremos que el coste de un algoritmo T(n) pertenece a (h(n)) cuando T(n) superar, para
grandes tallas, un mltiplo de g(n). En otras palabras, T(n) crece asintticamente ms
rpido que h(n), es decir, h(n) por una constante es una cota inferior de T(n).

Por tanto, utilizaremos la notacin asinttica O para catalogar el algoritmo en su

comportamiento en el peor de los casos, y la notacin para el caso mejor:
T(n) O(g(n))

=> T(n) es como mximo del orden de g(n)

T(n) (h(n))

=> T(n) es como mnimo del orden de h(n)

Por ltimo, si caso mejor y peor coinciden, podremos utilizar la notacin (g(n)).

3.3 Reglas generales

Para el estudio del coste temporal de los algoritmos se seguirn los siguientes pasos:

Determinar el tamao del problema; esto es, estudiar de qu parmetros va a depender

el coste.

Analizar si, para un tamao del problema fijo, existen instancias significativas para el
coste.

Obtener la funcin de coste. Si existen instancias significativas, el estudio de costes se

particularizar para el caso peor y el caso mejor. El estudio de costes en el caso peor
da una cota superior para el coste del algoritmo, utilizaremos en este caso la notacin
O.

3.3.1 Anlisis del coste de los algoritmos iterativos

Una forma de obtener la funcin de coste de un determinado algoritmo iterativo consiste en
contar el nmero de veces que se repite lo que llamaremos una instruccin crtica o instruccin
barmetro.
Una instruccin crtica en un determinado algoritmo es aquella que se ejecuta por lo menos con
tanta frecuencia como cualquier otra del algoritmo. En realidad no hay problema si hay alguna
instruccin que se ejecuta un nmero de veces constante ms que el barmetro, ya que
quedar absorbida en la notacin asinttica.
Ejemplo propuesto: Calcular el coste temporal en el peor y mejor caso en el algoritmo que
nos permite buscar un elemento dentro de un vector.

3.3.2 Anlisis del coste de los algoritmos recursivos

En el caso del estudio del coste de los algoritmos recursivos, podemos utilizar para su
resolucin la relacin de recurrencia utilizada a menudo como paso previo a la definicin del
algoritmo.
Ejemplo propuesto: Calcular el coste temporal y espacial en el algoritmo del clculo del
factorial recursivo.