Vous êtes sur la page 1sur 4

7.2.

Complejidad en el espacio
COMPLEJIDAD
Otra consideracin a tener en cuenta a la hora de tratar con la complejidad es que si
estamos contando el tiempo que tarda un algoritmo en resolver un problema En qu
ordenador lo ejecutamos? Parece obvio que el mismo algoritmo ejecutado en un
ordenador el doble de rpido que otro tardar la mitad en encontrar la solucin. Cul
debera ser entonces la unidad de medida de la complejidad? Ninguna unidad de tiempo
nos vale: ni segundos ni milisegundos, porque el resultado variara de un ordenador a
otro.
Adems el mismo algoritmo tardar ms o menos en solucionar un problema de una talla
u otra. Es decir, no puede tardarse lo mismo en ordenar un array de 100 valores que uno
de 100000.
Nos podemos permitir esa simplificacin porque lo que realmente queremos saber es
cmo crece el nmero de instrucciones necesarias para resolver el problema con respecto
a la talla del problema. Eso es realmente la complejidad.
Por ejemplo, observa sta funcin (da igual cul sea su propsito)

En este algoritmo hay un par de


bucles para que se ejecuten uno
despus del otro.
Observemos el primer bucle.
Se ejecuta n veces, y en su interior
hay una instruccin (la de la lnea 5).
Eso quiere decir que la lnea 5 se
ejecuta n veces.
Despus se ejecuta el segundo bucle,
que contiene en su interior dos
instrucciones (las de las lneas 8 y 9).
Como ese segundo bucle se ejecuta
tambin n veces y tiene dos instrucciones, se realizan 2n instrucciones.
Finalmente hay una instruccin en la lnea 11 que se ejecuta una sola vez.
El nmero de instrucciones que se ejecutan en total es n + 2n + 1 es decir, 3n + 1
Todava no hemos llegado al fondo de la cuestin, pero vamos encaminados. Podemos
decir que la complejidad de ese algoritmo es 3n + 1, porque ese es el nmero de
instrucciones que hay que realizar para solucionar el problema cuando la talla del
problema es n.
La idea que subyace es que podemos saber cmo se comporta el algoritmo conforme la
talla del problema va creciendo. En este caso, si se representa 3n + 1 con respecto a n
nos daremos cuenta de que esta funcin es una recta. Para este algoritmo podemos

suponer que cuando lo traslademos a un lenguaje de programacin concreto sobre un


ordenador concreto, si para un n = 100 tarda 7 unidades de tiempo en solucionarlo, con
unas pocas operaciones podemos deducir cuntas unidades de tiempo tarda para un n =
1000. Por supuesto, no es un valor exacto, pero lo que nos importa es saber de qu
manera aumenta el tiempo con respecto a la talla del problema.

TIEMPO DE EJECUCION DE UN ALGORITMO


Una medida que suele ser til conocer es el tiempo de ejecucin de un programa en
funcin de N, lo que denominaremos T(N). Esta funcin se puede medir fsicamente
(ejecutando el programa, reloj en mano), o calcularse sobre el cdigo contando
instrucciones a ejecutar y multiplicando por el tiempo requerido por cada instruccin. As,
un trozo sencillo de programa como
S1; for (int i= 0; i < N; i++)
S2; requiere T(N)= t1 + t2*N
siendo t1 el tiempo que lleve ejecutar la serie S1 de sentencias, y t2 el que lleve la
serie S2.
Prcticamente todos los programas reales incluyen alguna sentencia condicional,
haciendo que las sentencias efectivamente ejecutadas dependan de los datos concretos
que se le presenten. Esto hace que mas que un valor T(N) debamos hablar de un rango
de valores
Tmin(N) <= T(N) <= Tmax(N)
los extremos son habitualmente conocidos como caso peor y caso mejor. Entre ambos se
hallara algn caso promedio o ms frecuente. Cualquier frmula T(N) incluye referencias
al parmetro N y a una serie de constantes Ti que dependen de factores externos al
algoritmo como pueden ser la calidad del cdigo generado por el compilador y la
velocidad de ejecucin de instrucciones del ordenador que lo ejecuta. Dado que es fcil
cambiar de compilador y que la potencia de los ordenadores crece a un ritmo vertiginoso
(en la actualidad, se duplica anualmente), intentaremos analizar los algoritmos con algun
nivel de independencia de estos factores; es decir, buscaremos estimaciones generales
ampliamente vlidas.

COMPLEJIDAD EN ESPACIO

Es la memoria que utiliza un programa para su ejecucin. Lo que implica que la eficiencia en
memoria de un algoritmo lo indica la cantidad de espacio requerido para ejecutarlo, es decir, el
espacio memoria que ocupan todas las variables propias del algoritmo.
Es la memoria que utiliza un programa para su ejecucin; es decir, el espacio de memoria que
ocupan todas las variables propias del algoritmo.

Esta se divide en Memoria Esttica y Memoria Dinmica.

Memoria esttica. Para calcularla se suma de memoria que ocupan las variables declaradas en el
algoritmo.
Memoria dinmica. Su clculo no es tan simple ya que depende de cada ejecucin del algoritmo

Ejemplo1: algoritmo de bsqueda en arboles.Funcin bsqueda_arboles.


Devuelve una solucin o fallo.
Inicializa un rbol de bsqueda con estado inicial.
Bucle hacer
- Si no hay candidatos para expandir.
- Entonces devolver fallo.
- En otro caso escoger nodo para expandir.
- Si el nodo es el objetivo.
- Entonces devolver solucin.
- En otro caso expandir nodo.
M = profundidad mxima del rbol (puede ser infinita)
D = profundidad de la mejor solucin (menor costo)
B = factor de ramificacin (numero mximo de sucesiones) = 10
Depth Nodes

Time

Memory

1 milisecond 100 bytes

111

.1 second

11 Kb

11111

11 second

1 Mb

1000000 18 minutos 111 Mb

Ejemplo2:
Complejidad espacial:

public int getAverage ( int arr[] ) {


int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum / arr.length;
}
En el ejemplo anterior tenemos una funcin que nos permite obtener el promedio de un arreglo de
nmeros.

Como no podemos saber el nmero de elementos que tiene este arreglo decimos que
tiene n elementos int, adems tenemos un elemento int (sum)
Utilizando la notacin O podemos representar eso de la siguiente manera: O(n+1)
Ahora analicemos el siguiente mtodo:
Public void initMatrix (int mat [ ] [ ] ) {
for ( int i = 0; i < mat.length; i++ ) {
for ( int j = 0; j < mat[i].length; j++) {
mat [ i ][ j ] = 0;
}
}
}