N13 LibroDatosComplejidad

Diseño y Manejo de Estructuras de Datos en C – J. Villalobos – McGraw Hill (1996) 19 Diseño y Manejo de Estructuras de Datos en C – J.
Estructuras de Datos en C – J. Villalobos – McGraw Hill (1996) 20

Capítulo 0 - Conceptos Básicos Capítulo 0 - Conceptos Básicos
Adicional al tiempo de ejecución, existe otro factor que también se debe considerar al medir la eficiencia de un
0.3. Análisis de Algoritmos algoritmo: el espacio que ocupa en memoria. No tiene sentido escoger un algoritmo muy veloz, cuyas
exigencias de memoria puedan impedir su uso en algunas situaciones. Esta es la segunda medida que se va a
Una de las herramientas con que cuenta un ingeniero, para hacer la evaluación de un diseño, es el análisis de utilizar en el diseño de las estructuras de datos.
algoritmos. A través de éste, es posible establecer la calidad de un programa y compararlo con otros
programas que se puedan escribir para resolver el mismo problema, sin necesidad de desarrollarlos. El
análisis se basa en las características estructurales del algoritmo que respalda el programa y en la cantidad de 0.3.2. Tiempo de Ejecución de un Algoritmo
memoria que éste utiliza para resolver un problema.
Para poder tener una medida del tiempo de ejecución de un programa, se debe pensar en los factores que
El análisis de algoritmos se utiliza también para evaluar el diseño de las estructuras de datos de un programa, tienen influencia en dicho valor. Inicialmente, se pueden citar los siguientes:
midiendo la eficiencia con que los algoritmos del programa son capaces de resolver el problema planteado, si
• La velocidad de operación del computador en el que se ejecuta. Es diferente ejecutar el programa en un
la información que se debe manipular se representa de una forma dada.
micro 80386 que en un Pentium de 150 Mhz.
La presentación que se hace en esta sección del tema de análisis de algoritmos no es completa. Sólo se ven • El compilador utilizado (calidad del código generado). Cada compilador utiliza diferentes estrategias de
las bases para que el estudiante pueda evaluar los algoritmos que se presentan en el libro. Para una optimización, siendo algunas más efectivas que otras.
presentación más profunda se recomienda consultar la bibliografía que se sugiere al final del capítulo.
• La estructura del algoritmo para resolver el problema.
0.3.1. Definición del Problema Con excepción del último, los factores mencionados no son inherentes a la solución, sino a su
implementación, y por esta razón se pueden descartar durante el análisis.
Suponga que existen dos programas P1 y P2 para resolver el mismo problema. Para decidir cuál de los dos es
mejor, la solución más sencilla parece ser desarrollarlos y medir el tiempo que cada uno de ellos gasta para Además de la estructura del algoritmo, se debe tener en cuenta que el número de datos con los cuales trabaja
resolver el problema. Después, se podrían modificar los datos de entrada, de alguna manera preestablecida, y un programa también influye en su tiempo de ejecución. Por ejemplo, un programa para ordenar los elementos
promediar al final su desempeño para establecer su comportamiento en el caso promedio. de un vector, se demora menos ordenando un vector de 100 posiciones que uno de 500. Eso significa que el
tiempo de ejecución de un algoritmo debe medirse en función del tamaño de los datos de entrada que debe
La solución anterior tiene varios problemas. Primero, que pueden existir muchos algoritmos para resolver un procesar. Esta medida se interpreta según el tipo de programa sobre el cual se esté trabajando.
mismo problema y resulta muy costoso, por no decir imposible, implementarlos todos para poder llevar a cabo
la comparación. Segundo, modificar los datos de entrada para encontrar el tiempo promedio puede ser una Se define TA(n) como el tiempo empleado por el algoritmo A en procesar una entrada de tamaño n y producir
labor sin sentido en muchos problemas, llevando a que la comparación pierda significado. una solución al problema.
El objetivo del análisis de algoritmos es establecer una medida de la calidad de los algoritmos, que permita
compararlos sin necesidad de implementarlos. Esto es, tratar de asociar con cada algoritmo una función Ejemplo 0.25:
matemática que mida su eficiencia, utilizando para este efecto únicamente las características estructurales del Considere dos rutinas que invierten una lista sencillamente encadenada de n elementos. Ambas cumplen la
algoritmo. Así, se podrían llegar a comparar diversos algoritmos sin necesidad, siquiera, de tenerlos siguiente especificación:
implementados. Como una extensión de esto, sería posible comparar diferentes estructuras de datos,
tomando como factor de comparación el algoritmo más eficiente que se pueda escribir sobre ellas, para cab
X1 .... Xn
resolver un problema dado, tal como se sugiere en la figura 0.3. { pre: }
cab ....
Estructuras de Posibles Medida de Xn X1
Datos Algoritmos Eficiencia
{ post: }
ALGORITMO-1 f-1 El primero de los algoritmos en cuestión es el presentado en el ejemplo 0.20., que modifica los
ALGORITMO-2 f-i Mejor encadenamientos de la lista para invertirla. Hace solo una pasada sobre la estructura, haciendo en cada
DISEÑO-1 Algoritmo
... ... iteración el cambio de sentido de un apuntador. El segundo algoritmo es el que se desarrolla a
ALGORITMO-N f-N continuación, que, para invertir la lista, mueve la información en lugar de alterar los encadenamientos. Para
Mejores estructuras
de datos para resolver esto remplaza el primer elemento por el último, el segundo por el penúltimo, y así sucesivamente hasta
ALGORITMO-1 g-1 el problema? terminar, como se muestra en la siguiente secuencia:
ALGORITMO-2 g-k Mejor
DISEÑO-2 ... Algoritmo cab X1 X2 X3 .... XN
... XN-2 XN-1
(1)
ALGORITMO-M g-M
cab .... X1
XN X2 X3 XN-2 XN-1
Fig. 0.3- Análisis de algoritmos como herramienta para el diseño de estructuras de datos (2)
cab .... X1
XN XN-1 X3 XN-2 X2
(3)
Diseño y Manejo de Estructuras de Datos en C – J. Villalobos – McGraw Hill (1996) 21 Diseño y Manejo de Estructuras de Datos en C – J. Villalobos – McGraw Hill (1996) 22
Si se consideran los resultados obtenidos, lo que a primera vista podría parecer una pequeña ineficiencia
struct nodo *inv2( struct nodo *cab )
del segundo algoritmo, consistente en la relocalización -en cada iteración- del apuntador q, lleva a
{ int temp;
desempeños muy diferentes: mientras el primer algoritmo alcanza a invertir 240.000 nodos en menos de 1
struct nodo *p, *q, *r;
segundo, el segundo gasta más de 30 segundos en procesar sólo 10.000.
for( q = cab; q->sig != NULL; q = q->sig );
for( p = cab; p != q && q->sig != p; p = p->sig )
{ temp = p->info; Lo ideal, al hacer la evaluación de la eficiencia de un algoritmo, sería encontrar una función matemática que
p->info = q->info; describiera de manera exacta TA(n). Sin embargo, en muchos casos, el cálculo de esta función no se puede
q->info = temp; realizar, ya que depende de otro factor no considerado y que es, la mayoría de las veces, imposible de medir:
for( r = p; r->sig != q; r = r->sig ); el contenido o calidad de la entrada. Esto se ilustra en el siguiente ejemplo.
q = r;
}
return cab; Ejemplo 0.26:
} Considere el siguiente algoritmo, utilizado para decidir si el elemento elem se encuentra en un vector vec de N
posiciones.
El tamaño de los datos de entrada es el número de elementos de la lista encadenada. Los tiempos de
ejecución de cada algoritmo se resumen en la siguiente tabla y dan una idea de la eficiencia de cada uno: { pre: vec = [ X0, ..., XN-1 ] }
Algoritmo 1: tiempo de ejecución (tomado cada 20.000 nodos) { post: ( Xi = elem, existe = TRUE ) ∨ ( Xk != elem, ∀k  0 ≤ k < N, existe = FALSE ) }
# nodos T( n ) segs for( i = 0; i < N && vec[ i ] != elem; i++ );
20,000 0.05 existe = i < N;
40,000 0.05
60,000 0.11
1.00 Haciendo un análisis puramente teórico, se puede ver la influencia que tienen los datos específicos de la
0.90
entrada (no sólamente su cantidad) en el tiempo de ejecución. Suponga que se fija el valor de N en 6 y que
80,000 0.16
Tiempo de ejecución (segs)
0.80
0.70 la evaluación de cada expresión del programa toma t microsegundos. Si los datos de entrada son:
100,000 0.22
0.60
120,000 0.27 0.50
0.40
140,000 0.33 i = 0; t µseg
0.30
0 1 2 3 4 5
160,000 0.38 0.20 0 < 6 && vec[ 0 ] != 5 t µseg
vec = 5 6 7 8 9 10 , elem = 5
180,000 0.38 0.10
existe = 0 < 6; t µseg
0.00
200,000 0.44
20,000
40,000
60,000
80,000
100,000
120,000
140,000
160,000
180,000
200,000
220,000
240,000
220,000 0.55
240,000 0.60
Número de nodos procesados
El algoritmo gasta en total 3t microsegundos, como se puede apreciar en el desarrollo anterior. Mientras
que, para la siguiente entrada, el mismo algoritmo, con el mismo valor para N, toma 11t microsegundos.
Algoritmo 2: tiempo de ejecución (tomado cada 1.000 nodos)
# Nodos T(n) segs i = 0; t µseg
0 1 2 3 4 5
1,000 0.22 35.00 0 < 6 && vec[ 0 ] != 5; i++ 2t µseg
vec = 5 6 7 8 9 10 , elem = 9
30.00 1 < 6 && vec[ 1 ] != 5; i++ 2t µseg
2,000 1.32
Tiempo de ejecución (segs)

25.00 2 < 6 && vec[ 2 ] != 5; i++ 2t µseg
3,000 2.91
20.00 3 < 6 && vec[ 3 ] != 5; i++ 2t µseg
4,000 4.95 4 < 6 && vec[ 4 ] != 5;
15.00 t µseg
5,000 7.69 existe = 4 < 6;
10.00 t µseg
6,000 10.93
5.00
7,000 14.89 0.00
8,000 19.34
1,000
2,000
3,000
4,000
5,000
6,000
7,000
8,000
9,000
Esto implica que, por más que se conozca el tamaño de los datos de entrada, es imposible -para muchos
10,000
9,000 24.45 problemas- determinar el tiempo de ejecución para cada una de las posibles entradas.
Número de nodos procesados
10,000 30.16
Por la razón antes enunciada, se va a trabajar con el tiempo utilizado por el algoritmo en el peor de los casos, Complejidad 1 seg 102 seg 104 seg 106 seg 108 seg 1010 seg
ya que es mucho más fácil definir cuál es el peor de los casos, que considerarlos todos, o incluso, que (1.7 min) (2.7 horas) (12 días) (3 años) (3 siglos)
considerar el caso promedio. Se redefine la función de tiempo así: A1 1000n 103 105 107 109 1011 1013
A2 1000nlog2n 1.4 * 102 7.7 * 103 5.2 * 105 3.9 * 107 3.1 * 109 2.6 * 1011
TA( n ) = tiempo que se demora el algoritmo A, en el peor de los casos, para encontrar una solución a un
problema de tamaño n. A3 100n2 102 103 104 105 106 107
A4 10n3 46 2.1 * 102 103 4.6 * 103 2.1 * 104 105
Así, se pueden comparar dos algoritmos cuando tratan de resolver el mismo problema en el peor de los A5 n log2n 22 36 54 79 112 156
casos. Para el ejemplo 0.26, el peor de los casos es cuando no encuentra el elemento en el vector, puesto que
debe iterar N veces antes de darse cuenta de su inexistencia. A6 2n/3 59 79 99 119 139 159
A7 2n 19 26 33 39 46 53
En algunos casos particulares de este libro, sobre todo en los capítulos 4 y 5, se utiliza el cálculo de la
A8 3n 12 16 20 25 29 33
complejidad de un algoritmo en el caso promedio. Para eso se debe tener en cuenta la distribución
probabilística de los datos que se manejan. Allí se ilustra este proceso.
Un problema se denomina tratable si existe un algoritmo de complejidad polinomial para resolverlo. En otro
0.3.3. El Concepto de Complejidad caso se denomina intratable. Esta clasificación es importante porque, cuando el tamaño del problema
aumenta, los algoritmos de complejidad polinomial dejan de ser utilizables de manera gradual, como se puede
La idea detrás del concepto de complejidad es tratar de encontrar una función f( n ), fácil de calcular y apreciar en la figura 0.5. Por su parte, los algoritmos para resolver los problemas intratables explotan de un
conocida, que acote el crecimiento de la función de tiempo, para poder decir "TA(n) crece aproximadamente momento a otro, volviéndose completamente incapaces de llegar a una respuesta para el problema planteado.
como f" o, más exactamente, "en ningún caso TA(n) se comporta peor que f al aumentar el tamaño del En la figura 0.5 se puede apreciar cómo un algoritmo de complejidad O( 2n ) es capaz de resolver un
problema". En la figura 0.4. aparece la manera como crecen algunas de las funciones más utilizadas en el problema de tamaño 20 en 1 segundo, pero ya es completamente inutilizable para problemas de tamaño 50,
cálculo de la complejidad. puesto que se demoraría 35 años buscando la solución.
2n n3 n2 n log n El caso límite de los problemas intratables son los problemas indecidibles. Esos son problemas para los
cuales no existe ningún algoritmo que los resuelva.
Complejidad 20 50 100 200 500 1000
1000n 0.02 seg 0.05 seg 0.1 seg 0.2 seg 0.5 seg 1 seg
1000nlog2n 0.09 seg 0.3 seg 0.6 seg 1.5 seg 4.5 seg 10 seg
n 100n2 0.04 seg 0.25 seg 1 seg 4 seg 25 seg 2 min
10n3 0.02 seg 1 seg 10 seg 1 min 21 min 2.7 horas
n log2n 0.4 seg 1.1 horas 220 días 125 siglos
2n/3 0.001 seg 0.1 seg 2.7 horas 3*104 siglos
2n 1 seg 35 años 3*104 siglos
Fig. 0.4 - Crecimiento de las funciones típicas de complejidad de algoritmos
3n 58 min 2*109 siglos
Al afirmar que un algoritmo es O( f ( n ) ), se está diciendo que al aumentar el número de datos que debe Fig. 0.5 - Estimativos de tiempo para resolver un problema de tamaño N [TAR91]
procesar, el tiempo del algoritmo va a crecer como crece f en relación a n. En el ejemplo 0.25, una de las
rutinas para invertir la lista es O( n ), mientras que la otra es O( n2 ), y esto se puede apreciar claramente en la En el momento de calcular la complejidad de un algoritmo, se debe encontrar la función que mejor se ajuste al
forma de la gráfica de tiempos incluida en dicho ejemplo. crecimiento de TA(n), y no simplemente una cota cualquiera. En particular, todo algoritmo O( n ) es a la vez O(
n2 ), y también es O( f( n ) ), para toda función f que crezca más rápido que f( n ) = n.
Ejemplo 0.27:
Suponga que se tienen 8 algoritmos distintos A1, ..., A8 para resolver un problema dado, cada uno con una Formalmente, se dice que:
complejidad diferente. Si a cada algoritmo le toma 1 microsegundo procesar 1 dato, en la siguiente tabla
aparece el tamaño máximo del problema que puede resolver en una cierta unidad de tiempo [TAR91]. TA( n ) es O( f( n ) ) (la complejidad de A es f( n )) ssi ∃ c, n0 > 0 | ∀ n ≥ n0 , TA( n ) ≤ c f( n )
Allí se puede apreciar claramente cómo algunos algoritmos pueden resultar inaplicables para problemas de un
cierto tamaño.
Esto implica que, para demostrar que un algoritmo tiene complejidad f(n), se debe buscar un punto n0 sobre el La demostración se basa en la idea de que la suma de las funciones de tiempo T1 y T2, acotadas por f1 y f2
eje del tamaño del problema, a partir del cual se pueda garantizar el acotamiento de TA(n) por la función f(n), respectivamente, se puede acotar con una función de la misma forma que la cota que crezca más rápido de
ignorando los factores constantes de esta última (sólo interesa la forma de la función y no su valor exacto). las dos.
Teorema 0.3:
0.3.4. Aritmética en Notación O
Sea A1 un algoritmo que se repite itera(n) veces dentro de un ciclo, tal que itera(n) es O( f2(n) ) y TA1( n ) es
Para facilitar el cálculo de la complejidad de un algoritmo es necesario desarrollar aritmética en notación O, O( f1(n) ). El tiempo de ejecución del programa completo TA( n ) =TA1( n ) * itera( n ) es O( f1(n) * f2(n)),
de tal manera que sea posible dividir un algoritmo y, a partir del estudio de sus partes, establecer el cálculo suponiendo que el tiempo de evaluación de la condición se encuentra incluido en el tiempo de ejecución del
global. Las siguientes demostraciones utilizan la definición formal de complejidad. Más importante que la algoritmo A1.
demostración misma, es la interpretación intuitiva que se puede hacer de los resultados.
Este resultado permite que, al analizar un ciclo, se puedan estudiar primero el cuerpo y la condición, y
finalmente acotar el número de iteraciones con una función conocida, de manera que la unión de estos
Teorema 0.1: resultados sea sencilla.
Si TA( n ) es O( k f( n ) ) TA( n ) también es O( f( n ) ). Demostración:
Este teorema expresa una de las bases del análisis de algoritmos: lo importante no es el valor exacto de la Si TA1( n ) es O( f1( n ) ) ∃ c1,n1 > 0 | ∀ n ≥ n1 TA1( n ) ≤ c1.f1( n )
función que acota el tiempo, sino su forma. Esto permite eliminar todos los factores constantes de la función
Si itera( n ) es O( f2( n ) ) ∃ c2, n2 > 0 | ∀ n ≥ n2 itera( n ) ≤ c2.f2( n )
cota. Por ejemplo, un algoritmo que es O( 2n ) también es O( n ), puesto que ambas funciones tienen la misma
forma, aunque tienen diferente pendiente.
Demostración: TA( n ) = TA1( n ) * itera( n ) ≤ c1.f1( n ) * c2.f2( n ), ∀ n ≥ max( n1, n2 )
Si TA( n ) es O( k f( n ) ) ∃ c, n0 > 0 | ∀ n ≥ n0 , TA( n ) ≤ c.k.f( n ) TA( n ) ≤ ( c1 * c2 ) * f1( n ) * f2( n )
Al tomar c1 = c.k > 0 se tiene que Al tomar: n0 = max( n1, n2 ) > 0
∃ c1, n0 > 0 | ∀ n ≥ n0 TA( n ) ≤ c1.f( n ) c0 = ( c1 * c2 ) > 0, se tiene que:
TA( n ) es O( f( n ) ) ∃ co, n0 > 0 | ∀ n ≥ n0 TA( n ) ≤ co.f1( n ).f2( n )
TA( n ) es O( f1( n ) * f2( n ) )
Teorema 0.2:
Si A1 y A2 son algoritmos, tales que TA1( n ) es O( f1( n ) ) y TA2( n ) es O( f2( n ) ), el tiempo empleado en
0.3.5. Ejemplos
ejecutarse A1 seguido de A2 es O( max( f1( n ), f2( n ) ) ).
En los siguientes ejemplos se ilustra la manera de calcular la complejidad de un algoritmo, utilizando los
Esto quiere decir que si se tienen dos bloques de código y se ejecuta uno después del otro, la complejidad del
resultados obtenidos en la sección anterior. Los ejemplos van de lo elemental a lo complejo, y por esta razón
programa resultante es igual a la complejidad del bloque más costoso. Por esta razón, si hay una secuencia
es conveniente seguirlos en orden.
de comandos O( 1 ), también esta secuencia tendrá, en conjunto, complejidad constante. Pero si alguna de
sus instrucciones es O( n ), todo el programa será O( n ).
Demostración: Ejemplo 0.28:
Calcular la complejidad de la asignación var = 5.
Si TA1( n ) es O( f1( n ) ) ∃ c1,n1 > 0 | ∀ n ≥ n1,, TA1( n ) ≤ c1.f1( n )
Si TA2( n ) es O( f2( n ) ) ∃ c2, n2 > 0 | ∀ n ≥ n2, TA2( n ) ≤ c2.f2( n ) Este programa es O(1), porque una asignación que no tiene llamadas a funciones se ejecuta en un tiempo
constante, sin depender del número de datos del problema. Si Tk es el tiempo que toma la asignación
(expresado en cualquier unidad de tiempo), TA( n ) es O( Tk ) puesto que se puede acotar con una función
TA( n ) = TA1( n ) + TA2( n ) ≤ c1.f1( n ) + c2.f2( n ), ∀ n ≥ max( n1, n2 ) constante con ese mismo valor:
T A (n)
TA( n ) ≤ ( c1 + c2 ) * max( f1( n ), f2( n ) ), ∀ n ≥ max( n1, n2 )
Tk
Al tomar: n0 = max( n1, n2 ) > 0
c0 = ( c1 + c2 ) > 0, se tiene que: 10
|
20
|
30
|
40
|
n
∃ co, n0 > 0 | ∀ n ≥ n0 TA( n ) ≤ co.max( f1( n ), f2( n ) )
De acuerdo con el teorema 0.1., si TA( n ) es O( Tk ) TA( n ) también es O( 1 ).
TA( n ) es O( max( f1( n ), f2( n ) ) )
Ejemplo 0.29: Para calcular la complejidad de un algoritmo se suele comenzar de arriba hacia abajo y de adentro hacia
afuera (en el caso de ciclos).
Calcular la complejidad del programa:
El subprograma:
x = 1; i = 0;
y = 2; acum = 1;
z = 3;
es O( 1 ) lo mismo que la instrucción:
La complejidad de cada asignación es O( 1 ), según se mostró en el ejemplo anterior. De acuerdo con el return acum;
teorema 0.2., se puede concluir que TA( n ) es O( max( 1,1,1 ) ), es decir O( 1 ). Intuitivamente se puede
establecer esta misma respuesta, al verificar que el número de asignaciones no depende del tamaño del Para calcular la complejidad del ciclo se comienza por evaluar la complejidad del subprograma asociado,
problema que se quiere resolver. incluyendo la evaluación de la condición.
while ( i < num )
{ i++;
Ejemplo 0.30: acum *= i;
Calcular la complejidad del programa x = abs( y ), donde abs( ) es una función con el siguiente código: }
Tanto la comparación como las dos asignaciones son O( 1 ). Ahora, se busca una función que acote el
float abs( float n ) número de iteraciones del ciclo. En este caso, podemos escoger f( num ) = num, puesto que éste nunca se
{ if ( n < 0 ) va a ejecutar más de num veces.
return -n;
else Esto hace que:
return n; Twhile( num ) sea O( num * 1 ) = O( num )
}
Y la complejidad de toda la función:
Primero, se debe calcular la complejidad de la función, ya que la asignación va a tener la complejidad de la
llamada. Tfact( num ) es O( max( 1, num, 1 ) ) = O( num )
El tiempo de ejecución de la instrucción if se puede acotar con el tiempo de evaluación de la condición más En todos los casos, la complejidad de una función debe quedar en términos de sus parámetros de entrada,
el tiempo de ejecución del subprograma más demorado de los dos asociados con la estructura condicional. puesto que son los que definen el tamaño del problema.
Tabs( n ) ≤ Tcond + max( Treturn, Treturn ) ≤ Tcond + Treturn El programa x = fact( n ) es O( n ), porque ese es el costo de evaluar la parte derecha de la asignación.
Ahora, la condición ( n < 0 ) es O( 1 ) porque toma un tiempo constante ejecutarla. Lo mismo sucede con la
instrucción return. Entonces,
Ejemplo 0.32:
Tabs( n ) es O( max( 1,1 ) ) = O( 1 ) Calcular la complejidad del siguiente programa:
Esto hace que la asignación x = abs( y ) sea a su vez O( 1 ).
for ( i = 0; i < 9; i++ )
a[ i ] = 0;
Ejemplo 0.31: La complejidad del ciclo es O(1), porque equivale a 9 asignaciones y siempre va a tomar un tiempo
Calcular la complejidad del programa x = fact( n ), si la función fact viene dada por el siguiente código: constante. Note que este programa se podría reescribir como:
a[ 0 ] = 0;
int fact( int num ) a[ 1 ] = 0;
{ int i, acum; a[ 2 ] = 0;
i = 0; a[ 3 ] = 0;
acum = 1; a[ 4 ] = 0;
while ( i < num ) a[ 5 ] = 0;
{ i++; a[ 6 ] = 0;
acum *= i; a[ 7 ] = 0;
} a[ 8 ] = 0;
return acum;
} Y por lo visto en ejemplos anteriores es O( 1 ).
Ejemplo 0.33: void ordenar( int vec[ ] )
{ int i, temp, pos;
Calcular la complejidad del siguiente procedimiento, que inicializa un vector de tamaño tam.
for ( i = 0; i < N - 1; i++ )
{ pos = posMenor( vec, i );
void inic( int a[ ], int tam )
temp = vec[ i ];
{ int i;
vec[ i ] = vec[ pos ];
for ( i = 0; i < tam; i++ )
vec[ pos ] = temp;
a[ i ] = 0;
}
}
}
En este caso la rutina es O( tam ), porque el tiempo de ejecución va a depender, de manera proporcional,
int posMenor( int vec[ ], int desde )
del tamaño del vector. Es importante apreciar la diferencia entre este ejemplo y el anterior, que a primera
{ int i, menor;
vista pueden parecer semejantes. En este ejemplo el número de asignaciones no es fijo, y el tiempo que va
menor = desde;
a demorar en ejecutarse la rutina va a depender del tamaño del vector que se debe inicializar. Si el tamaño
for ( i = desde + 1; i < N; i++ )
es N, se va a demorar T segundos, mientras que si es 2N se va a gastar 2T segundos.
if ( vec[ i ] < vec[ menor ] )
menor = i;
return menor;
Ejemplo 0.34: }
Calcular la complejidad del siguiente programa, que suma dos matrices mat1 y mat2 de dimensión N*M y deja
el resultado en una tercera matriz mat3 de las mismas dimensiones: TposMenor es O( N ), porque en el peor de los casos el parámetro de entrada desde vale 0, y debe recorrer
todo el vector buscando el menor elemento. Tordenar, por su parte, es O( N2 ), puesto que repite N veces la
for ( i = 0; i < N; i++ ) llamada de la otra función.
for ( k = 0; k < M; k++ )
mat3[ i ][ k ] = mat1[ i ][ k ]+ mat2[ i ][ k ];
El ciclo interno es O( M ), porque la asignación es O( 1 ) y se repite M veces. Puesto que el ciclo exterior se Ejemplo 0.37:
repite N veces, el programa completo es O( N*M ). La búsqueda binaria es un proceso muy eficiente para localizar un elemento en un vector ordenado. En cada
iteración, el algoritmo compara el valor que está buscando con el elemento que se encuentra en la mitad del
vector, y, basado en si el elemento es menor o mayor, descarta la otra mitad de los valores, antes de continuar
el proceso de búsqueda bajo el mismo esquema. El código de dicha rutina es el siguiente:
Ejemplo 0.35:
Establecer la complejidad de un procedimiento que calcula e imprime la longitud de una lista encadenada: int busquedaBinaria( int vec[ ], int elem, int dim )
{ int desde = 0;
void impLongitud( struct Nodo* cab ) int hasta = dim - 1;
{ int cont; int mitad;
struct Nodo *p; while( desde <= hasta )
cont = 0; { if( vec[ mitad = ( desde + hasta + 1 ) / 2 ] == elem )
for ( p = cab; p != NULL; p = p->sig ) return TRUE;
cont ++; if( vec[ mitad ] > elem )
printf( "%d", cont ); hasta = mitad - 1;
} else
desde = mitad + 1;
El tiempo de ejecución de este algoritmo es O( n ), donde n es el número de elementos presentes en la }
lista encadenada. Note que, en este caso, la complejidad se da en función de un valor implícito en un return FALSE;
parámetro de entrada. Para este cálculo, suponemos que todas las operaciones de entrada/salida se }
ejecutan en tiempo constante.
Puesto que el cuerpo del ciclo es evidentemente O( 1 ), el problema se reduce a encontrar una función que
acote el número de iteraciones del ciclo. La primera posibilidad es utilizar la función f( dim ) = dim (donde
Ejemplo 0.36: dim es el tamaño del vector), puesto que nunca va a entrar más de dim veces al ciclo. Pero, dado que en
cada iteración se reduce a la mitad el tamaño del problema, es mejor, como cota del número de
Calcular la complejidad de una rutina que ordena un vector de tamaño N. La rutina se encuentra apoyada por iteraciones, una función f( dim ), que cumpla que 2f( dim ) = dim (v.g. 2 al número de iteraciones es igual al
un función que retorna el menor elemento de un vector a partir de una posición dada:
tamaño del vector). Despejando de allí la función, se obtiene que la complejidad de la búsqueda binaria es figura 0.6. Además, este es un factor que se puede ajustar en la implementación del algoritmo, lo cual
O(log2dim). hace que la calidad de la programación del algoritmo deba ser tenida en cuenta.
T( n ) 8n
Este algoritmo resulta tan eficiente, que encontrar un valor en un vector de 25.000 elementos requiere
solamente 15 comparaciones.
4n
0.3.6. Complejidad en Espacio
2n
La misma idea que se utiliza para medir la complejidad en tiempo de un algoritmo se utiliza para medir su
complejidad en espacio. Decir que un programa es O( N ) en espacio significa que sus requerimientos de n
memoria aumentan proporcionalmente con el tamaño del problema. Esto es, si el problema se duplica, se
necesita el doble de memoria. Del mismo modo, para un programa de complejidad O( N2 ) en espacio, la
cantidad de memoria que se necesita para almacenar los datos crece con el cuadrado del tamaño del Fig. 0.6 - Funciones cota con diferentes constantes asociadas
problema: si el problema se duplica, se requiere cuatro veces más memoria. En general, el cálculo de la
complejidad en espacio de un algoritmo es un proceso sencillo que se realiza mediante el estudio de las • El rango de tamaños del problema en el cual debe trabajar eficientemente el algoritmo. Para cierto número
estructuras de datos y su relación con el tamaño del problema. de datos, un algoritmo de complejidad O( n2 ) puede ser más eficiente que uno de complejidad O( n ), o
incluso que uno O( 1 ), como se sugiere en la figura 0.7. Por eso se debe determinar el rango de datos
El problema de eficiencia de un programa se puede plantear como un compromiso entre el tiempo y el espacio para el cual se espera que el algoritmo sea eficiente.
utilizados. En general, al aumentar el espacio utilizado para almacenar la información, se puede conseguir un
mejor desempeño, y, entre más compactas sean las estructuras de datos, menos veloces resultan los T( n )
algoritmos. Lo mismo sucede con el tipo de estructura de datos que utilice un programa, puesto que cada una O( n*n )
de ellas lleva implícitas unas limitaciones de eficiencia para sus operaciones básicas de administración. Por
eso, la etapa de diseño es tan importante dentro del proceso de construcción de software, ya que va a
determinar en muchos aspectos la calidad del producto obtenido. O( n )
0.3.7. Selección de un Algoritmo
La escogencia de un algoritmo para resolver un problema es un proceso en el que se deben tener en cuenta O(1)
muchos factores, entre los cuales se pueden nombrar los siguientes:
• La complejidad en tiempo del algoritmo. Es una primera medida de la calidad de una rutina, y establece su
comportamiento cuando el número de datos que debe procesar es muy grande. Es importante tenerla en
cuenta, pero no es el único factor que se debe considerar.
• La complejidad en espacio del algoritmo. Es una medida de la cantidad de espacio que necesita la rutina Fig. 0.7 - Comparación de varias funciones para valores pequeños de un problema
para representar la información. Sólo cuando esta complejidad resulta razonable es posible utilizar este
algoritmo con seguridad. Si las necesidades de memoria crecen desmesuradamente con respecto al 0.3.8. Complejidad de Rutinas Recursivas
tamaño del problema, el rango de utilidad del algoritmo es bajo y se debe descartar.
• La dificultad de implementar el algoritmo. En algunos casos el algoritmo óptimo puede resultar tan difícil de Antes de comenzar esta sección, vale la pena advertir que el cálculo de la complejidad de una función
implementar, que no se justifique desarrollarlo para la aplicación que se le va a dar a la rutina. Si su uso es recursiva puede resultar, en algunos casos, un problema matemático difícil de resolver. Para los problemas
bajo o no es una operación crítica del programa que se está escribiendo, puede resultar mejor adoptar un sencillos, como los presentados a través de ejemplos en esta parte, la solución matemática exacta es trivial. A
algoritmo sencillo y fácil de implementar, aunque no sea el mejor de todos. lo largo del libro, cuando se haga el cálculo de la complejidad de una función recursiva cuya deducción no sea
simple, se hará una presentación intuitiva del resultado, en lugar de una demostración formal.
• El tamaño del problema que se va a resolver. Si se debe trabajar sobre un problema de tamaño pequeño
(v.g. procesar 20 datos), da prácticamente lo mismo cualquier rutina y cualquier estructura de datos para Para las rutina iterativas, la solución planteada consistía básicamente en encontrar una función cota para el
representar la información. No vale la pena complicarse demasiado y es conveniente seleccionar el tiempo de ejecución T( n ), mediante el estudio estructural del algoritmo. Ahora, el problema radica en que
algoritmo más fácil de implementar o el que menos recursos utilice. dicha función de tiempo se encuentra definida en términos de sí misma, y ya no es posible hacer una
• El valor de la constante asociada con la función de complejidad. Si hay dos algoritmos A1 y A2 de descomposición para estudiar el algoritmo, sino se hace necesaria la solución de una ecuación de
complejidad O( f( n ) ), el estudio de la función cota debe hacerse de una manera más profunda y precisa recurrencia.
en ambos casos, para tratar de establecer la que tenga una menor constante. Las diferencias en tiempo
de ejecución de dos rutinas con la misma complejidad pueden ser muy grandes, como se muestra en la En los siguientes ejemplos se ilustra el proceso:
Ejemplo 0.38:
int esta( struct Nodo *lst, int elem )
Calcular la complejidad de la función factorial:
{ if( lst == NULL )
return FALSE;
int factorial( int num )
else if( lst->info == elem )
{ if ( num == 0 )
return TRUE;
return 1;
else
else
return esta( lst->sig, elem );
return num * factorial( num - 1 );
}
}
Primero se calcula la complejidad de la segunda función. Para ésta, la ecuación de recurrencia es:
La función de tiempo de ejecución T( num ), se puede plantear mediante la siguiente ecuación de
recurrencia: 1, n=0
Testa(n) =
Tk, num = 0 1 + Testa(n − 1), n > 0
T(num) =
Tk + T(num − 1), num > 0
Por las siguientes razones:
En ella aparece expresado que si num vale cero, la función toma un tiempo constante en calcular la • El parámetro n corresponde al número de nodos de la lista, y define el tamaño del problema, de
respuesta. Si el parámetro num tiene un valor mayor que cero, el tiempo total viene definido como la suma manera que la ecuación de recurrencia debe estar definida en términos suyos.
del tiempo de calcular el factorial de num-1, más un tiempo constante, correspondiente a la multiplicación y • El tiempo de ejecución que interesa medir es el del peor de los casos, y éste corresponde a la situación
al retorno de la respuesta. en la cual el elemento no aparece en la lista. Esto implica que sólo se utiliza la primera salida de la
recursión.
La solución de dicha ecuación se puede hacer mediante la expansión simple de la recurrencia, como se
muestra a continuación: • En lugar de la constante Tk se utiliza el valor 1, porque según se pudo apreciar en el ejemplo anterior,
el valor de dicha constante es intrascendente para el resultado final.
T( num ) = Tk + T( num-1 )
= Tk + Tk + T( num-2 ) La solución se obtiene por expansión simple de la recurrencia, como en el ejemplo anterior, y se llega a
que Testa( n ) es O( n ).
= Tk + Tk + Tk + T( num-3 )
=… Para la función num, la ecuación de recurrencia para el tiempo de ejecución en el peor de los casos es:
1, n1 = 0
= num * Tk + T( 0 ) Tnum(n1,n2) =
Testa(n2) + 1 + Tnum(n1 − 1,n2), n1 > 0
= Tk * ( num + 1 )
Donde n1 es el número de nodos de lst1 y n2 es el número de nodos de lst2. La solución de esta ecuación
De allí se puede concluir que T( num ) es O( num+1 ) T( num ) es O( num ). lleva a lo siguiente:
Tnum( n1, n2 ) = Testa( n2 ) + 1 + Tnum( n1-1, n2 )
Ejemplo 0.39: = Testa( n2 ) + 1 + Testa( n2 ) + 1 + Tnum( n1-2, n2 )
Calcular la complejidad de una función recursiva que cuente el número de elementos que tienen en común =…
dos listas encadenadas no ordenadas, sin elementos repetidos:
= n1 * ( Testa( n2 ) + 1 ) + Tnum( 0, n2 )
int num( struct Nodo *lst1, struct Nodo *lst2 ) = n1 * ( Testa( n2 ) + 1 ) + 1
{ if( lst1 == NULL )
return 0; Puesto que Testa( n2 ) es O( n2 ), se obtiene que Tnum( n1, n2 ) es O( n1 * n2 ).
else if( esta( lst2, lst1->info )
return 1 + num( lst1->sig, lst2 );
else
return num( lst1->sig, lst2 );
}
Esta función utiliza una segunda rutina recursiva que informa si un elemento se encuentra en una lista
encadenada, cuyo código es:
Ejemplo 0.40: void proc( int n )
Calcular la complejidad de la implementación recursiva de la búsqueda binaria. { int i, k;
i = 1;
int busqueda( int vec[ ], int elem, int limiteInf, int limiteSup ) while ( i <= n )
{ int medio; { k = i;
if ( limiteInf > limiteSup ) while ( k <= n )
return FALSE; k++;
else if ( vec[ medio = ( limiteInf + limiteSup + 1 ) / 2 ] == elem ) k = 1;
return TRUE; while ( k <= i )
else if ( elem < vec[ medio ] ) k++;
return busqueda( vec, elem, limiteInf, medio-1 ); i++;
else }
return busqueda( vec, elem, medio+1, limiteSup ); }
}
0.60. Calcular la complejidad del siguiente algoritmo, teniendo en cuenta que num es una potencia de 2 (v.g.
La ecuación de recurrencia resultante es: 2,4,8,16,...):
1, n≤1 void proc( int num )
T(n) =
1 + T(n/2), n > 1 { int i;
i = 2;
Por las siguientes razones: while ( i < num )
i *= 2;
• El tamaño del problema corresponde al número de elementos entre las marcas de limiteInf y limiteSup. }
Dicho valor se denomina en este caso n. Cuando sólo queda un elemento en ese rango, o el rango sea
vacío, utiliza la primera salida de la recursión. 0.61. Calcular la complejidad del siguiente algoritmo, sabiendo que val es un entero positivo:
• La segunda salida se puede ignorar, porque en el peor de los casos nunca la utiliza. void proc( int val )
• Los dos avances de la recursión disminuyen a la mitad el tamaño del problema, y, sin importar cual de { int i, k, t;
los dos utilice, va a gastar el mismo tiempo. i = 1;
while ( i <= val - 1)
Al resolver la ecuación de recurrencia por simple expansión se obtiene: { k = i + 1;
while (k <= val)
T( n ) = 1 + T( n / 2 )
{ t = 1;
= 1 + 1 + T( n / 4 ) while (t <= k)
t++;
= 1 + 1 + 1 + T( n / 8 )
k++;
=… }
i++;
= log2n * 1 + T( n / n ) (suponiendo que n es potencia de 2) }
}
= log2n + 1
0.62. Calcular la complejidad del siguiente procedimiento, sabiendo que n es un entero positivo:
Por lo tanto, T( n ) es O( log2n )
void proc( int n )
{ int i = 1, k;
while ( i <= n )
Ejercicios Propuestos { k = n - i;
0.57. Desarrollar una rutina iterativa, de complejidad O(N), que lea una lista encadenada. N es el número de while ( k >= 1)
elementos leídos. k = k / 5;
i++;
0.58. Calcular la complejidad de un programa que multiplique dos matrices cuadradas. }
0.59. Calcular la complejidad del siguiente procedimiento, teniendo en cuenta que n es un entero positivo: }
Diseño y Manejo de Estructuras de Datos en C – J. Villalobos – McGraw Hill (1996) 37
Capítulo 0 - Conceptos Básicos
0.63. Calcular la complejidad de los algoritmos que resuelven los ejercicios propuestos de todas las
secciones anteriores.
0.64. Sea P( n ) = a0 + a1n + a2n2 + ... + amnm, un polinomio de grado m. Demostrar que si un algoritmo A
tiene complejidad O( P( n ) ), entonces también es O( nm ).
0.65. Implementar un algoritmo de multiplicación de matrices. Graficar la curva de tiempo de ejecución
para matrices de diferentes tamaños. Comparar los resultados obtenidos con los teóricos.
0.66. Implementar el algoritmo de búsqueda binaria, de manera recursiva e iterativa. Construir una gráfica
de tiempos de ejecución para el peor de los casos, en la cual se pueda apreciar la complejidad
logarítmica. Utilizar esta gráfica para calcular el sobrecosto que tiene en términos de la constante, una
rutina recursiva sobre una rutina iterativa.
0.67. Considere el siguiente problema: rotar k posiciones los elementos de un vector de N casillas. Rotar
una posición significa desplazar todos los elementos una posición hacia la izquierda y pasar a la última
posición el que antes se encontraba de primero. Desarrolle dos rutinas que lo resuelvan, de manera que
una tenga complejidad O(N) y la otra O(N*k). Impleméntelas y grafique el tiempo de ejecución a medida
que crecen N y k.
Bibliografía
Algoritmos: Metodología de desarrollo
• [CAR91] Cardoso, R., "Verificación y Desarrollo de Programas", Ediciones Uniandes, 1991.
• [DAL86] Dale, N., Lilly, S., "Pascal y Estructura de Datos", McGraw-Hill, 1986.
• [DIJ76] Dijkstra, E. W., "A Discipline of Programming", Prentice-Hall, 1976.
• [DRO82] Dromey, R.G., "How to Solve it by Computer", Prentice Hall, 1982.
• [GRI81] Gries, D., "The Science of Programming", Springer-Verlag, 1981.
Recursión:
• [FEL88] Feldman, M., "Data Structures with Modula-2", Prentice-Hall, 1988..
• [KRU87] Kruse, R., "Data Structures & Program Design", 1987.
• [MAR86] Martin, J., "Data Types and Data Structures", Prentice-Hall, 1986.
• [ROB86] Roberts, E., "Thinking Recursively", John Wiley & Sons, 1986.
• [WIR86] Wirth, N., "Algorithms & Data Structures", Prentice-Hall, 1986.
Análisis de Algoritmos:
• [AHO74] Aho, A., Hopcroft, J., Ullman, J., "The Design and Analysis of Computer Algorithms", Addison-
Wesley, 1974.
• [AHO83] Aho, A., Hopcroft, J., Ullman, J., "Data Structures and Algorithms", Addison-Wesley, 1983.
• [FEL88] Feldman, M., "Data Structures with Modula-2", Prentice-Hall, 1988..
• [LIP87] Lipschutz, S., "Estructura de Datos", McGraw-Hill, 1987.
• [TAR91] Tarjan, R., "Data Structures and Network Algorithms", Society for Industrial and Applied
Mathematics, 1991.

N13 LibroDatosComplejidad

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

N13 LibroDatosComplejidad

Cargado por

Copyright:

Formatos disponibles

Diseño y Manejo de Estructuras de Datos en C – J. Villalobos – McGraw Hill (1996) 19 Diseño y Manejo de Estructuras de Datos en C – J.

Estructuras de Datos en C – J. Villalobos – McGraw Hill (1996) 20

Tiempo de ejecución (segs)

También podría gustarte