8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

ANÁLISIS DE ALGORITMOS: La herramienta utilizada para la evaluación del diseño es

el análisis de algoritmos y de esta forma se determina la calidad de un programa que sea
comparable con otros que resuelvan el mismo problema sin necesidad de implementarlos.

PROBLEMA: Comúnmente para decidir cuál es la mejor solución a un problema entre

dos algoritmos P y Q que resuelven el mismo problema, parece ser desarrollarlos, y medir
el tiempo que cada uno de ellos tarda en resolverlo.

El objetivo del análisis de algoritmos es determinar una función

matemática que mida su eficiencia utilizando únicamente las
características estructurales del algoritmo sin necesidad de
implementarlo.

TIEMPO DE EJECUCIÓN DE UN ALGORITMO: Factores que tienen influencia en el

tiempo de ejecución.

 La velocidad de operación de un computador.

 El lenguaje de programación utilizado.
 La estructura del algoritmo.

Los dos primeros factores se deben descartar ya que son inherentes a la implementación.
El tercer factor es relevante a la solución y debe tenerse en cuenta durante el análisis

Otro factor que debe tenerse en cuenta, es el tamaño de los datos de entrada que tendrá
que procesar el algoritmo.

Ejemplo 1:
Se tienen dos algoritmos que invierten una lista sencillamente encadenada de n
elementos:

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 1
 8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

El tamaño de los datos de entrada, es el número de nodos de la lista encadenada. Los

tiempos de ejecución de cada algoritmo se resumen en la siguiente tabla.

El primer algoritmo modifica los “punteros de encadenamiento” realizando una sola

pasada en la lista para invertirla.

p = nulo;
q = cabeza;
r = qsiguiente;

MQ ( q != nulo )
qsiguiente = p;
p q;
q = r;
si ( r != nulo)
r = rsiguiente;
FMQ
Cabeza = p;

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 2
 8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

El segundo algoritmo mueve la información de un nodo a otro para invertirla.

Analizando el comportamiento de los dos algoritmos, evidencia la ineficiencia del segundo

algoritmo, ya que mientras el algoritmo-1 alcanza a invertir 240.000 nodos en menos de
un segundo, el algoritmo-2 tarda más de 30 segundos en procesar sólo 10.000 nodos.

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 3
 8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

Ejemplo 2:
El siguiente algoritmo busca el elemento elem en vector de tamaño N.

Como se puede apreciar, para muchos algoritmos aun conociendo el tamaño de los datos
de entrada, es imposible determinar el tiempo de ejecución para cada una de las posibles
entradas.

Por esta razón es muy conveniente trabajar con el tiempo utilizado por un algoritmo en el
peor de los casos.

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.

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 4
 8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

CONCEPTO DE COMPLEJIDAD: Es encontrar una función f(n) fácil de calcular y

conocida que acote el crecimiento de la función de tiempo. TA(n).

Cuando decimos que un algoritmo es O( f( n ) ), se está diciendo que cuando aumenta n

“tamaño de los datos”, el tiempo de ejecución crece como crece f en función de n.

En el ejemplo de invertir la lista sencillamente encadenada, el algoritmo-1 es O( n ) y el

algoritmo-2 O( n2 )

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 5
 8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

Ejemplo 3:
Se tienen 8 algoritmos A1…A8 que resuelven el mismo problema, pero cada uno con
diferente complejidad. Si a cada algoritmo le toma 1 microsegundo en procesar un dato,
en la siguiente tabla se aprecia el tamaño máximo del problema que puede resolver.

Como se puede apreciar, algunos algoritmos resultan inaplicables a medida que el tamaño
de los datos crece.

 Ejercicio de los números perfectos.

Un problema se denomina tratable si existe un algoritmo de complejidad polinomial para

resolverlo, de otra forma se consideran intratables.

Observe como un algoritmo de complejidad O ( 2n ) resuelve un problema de tamaño 20

en un segundo pero es inutilizable para problemas de tamaño 50.

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 6
 8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

ARITMETICA EN NOTACION O.

Teorema-1: Un algoritmo de complejidad O ( 2n ) es igual que otro de complejidad O ( n ).

No es importante el valor exacto sino su forma. En estos dos casos lo que varia es la
pendiente.

Teorema-2: Si A1 y A2 son algoritmos que se ejecutan uno seguido del otro, el tiempo
empleado es O( max ( f1 ( n ), f2 ( n ) ) ). Dos bloques de código que se ejecutan uno
después del otro, la complejidad del programa resultante es la complejidad del bloque
más costoso.

Teorema-3: La complejidad de un ciclo se calcula, encontrando la complejidad de las

instrucciones del cuerpo de ciclo multiplicada por la cantidad de iteraciones.
O( f1 ( n ) *, f2 ( n ) ).

Ejemplo-4:
Calcular la complejidad de la asignación:

Var = 5;

La complejidad 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.

Ejemplo-5:
Calcular la complejidad del algoritmo:

X = 1;
Y = 2;
Z = 3;

La complejidad es O( 1 ) debido al teorema-2 O( max (1, 1, 1) )

X = 1; O( 1 )
Y = 2; O( 1 )
Z = 3; O( 1 )

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 7
 8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

Ejemplo-6:
Calcular la complejidad de la siguiente asignación:

X = abs( y );

Donde la función abs( ) tiene el siguiente código:

float abs (float n)

{
If ( n < 0) return –n;
return n;
}

El primer paso consiste en calcular la complejidad de la función, ya que esta afectar la

asignación.

Las asignaciones, las condiciones y los retornos se consideran O ( 1 ), por tanto la

complejidad de la función es O ( 1 ) y por consiguiente la asignación x = abs( y ) también es
O( 1 ).

Ejemplo-7:
 Calcular la complejidad del siguiente método:

int fact( int num )

{ int i, acum;

i = 0;
acum = 1;

while ( i < num )

{
i++;
acum *= I;
}
return acum;
}

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 8
 8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

Solución:

int fact( int num )

{ int i, acum;

i = 0;  O( 1 ) O( 1 )
acum = 1;  O( 1 )

while ( i < num )  O( num )

{
i++;  O( 1 ) O( num ) O( num )
acum *= I;  O( 1 )
}

return acum;  O( 1 ) O( 1 )
}

Ejemplo-8:
 Calcular la complejidad del siguiente bloque de código:

for( i=0; i < 9; i++)

a[ i ] = 0;

Solución:

La complejidad es O ( 1 ) por que equivale a 9 asignaciones y siempre va a tomar un

tiempo constante.

a[ 0 ] = 0; O( 1 )
a[ 1 ] = 0; O( 1 )
a[ 2 ] = 0; O( 1 )
a[ 3 ] = 0; O( 1 )
a[ 4 ] = 0; O( 1 ) O( 1 )
a[ 5 ] = 0; O( 1 )
a[ 6 ] = 0; O( 1 )
a[ 7 ] = 0; O( 1 )
a[ 8 ] = 0; O( 1 )

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 9
 8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

Ejemplo-9:
 Calcular la complejidad del siguiente método:

void incic ( int a[ ], int tam )

{
int I;
for ( i = 0; i < tam; i++ )
a[ i ] = 0;
}

Ejemplo-10:
 Calcular la complejidad del siguiente bloque de código:

for ( i=0; i < n; i++)

for ( j=0; j < m; j++)
mat3[ i ] [ j ] = mat1[ i ] [ j ] + mat2[ i ] [ j ];

Ejemplo-11:
 Calcular la complejidad del siguiente bloque de código:

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 10
 8 de febrero de 2012 [ANALISIS DE ALGORITMOS]

Ejemplo-12:
Encuentre la complejidad del algoritmo “búsqueda binaria”. Recuerde que para realizar la
búsqueda binaria de un elemento en un vector, el vector debe estar ordenado
ascendentemente.

Bibliografía: Estructuras de datos en C++, Jorge Villalobos – Capítulo 0 – Conceptos Básicos Página 11