FACULTAD DE INGENIERA

Ingeniera en Software
Anlisis de Algoritmos

Establecimiento Pblico de
Educacin Superior, adscrito al
Departamento de Antioquia

Taller N 1: Clculo de la complejidad de un algoritmo

Perodo 01 de 2015
Prof.: Ricardo Botero Tabares

Indicador de logro
Calcula el orden de magnitud o tiempo de ejecucin en el peor de los casos,
como medida de la complejidad de un algoritmo, basado en el contador de
frecuencias.
Ejercicios propuestos
A. Determinar el contador de frecuencias y el orden de magnitud de los
siguientes algoritmos, teniendo en cuenta las restricciones de cada punto.
1.

Restriccin: n es un nmero entero positivo.

1.1.

int funcion1 (int n){

int c = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++)
for (int k = 1; k <= j; k++)
c++;
return c;
}
1.2.

int funcion2 (int n){

int cont = 0, acum = 2;
while (acum <= n) {
cont++;
acum *= acum;
}
return cont;
}

1.3

void rutina1 (int n){

int c1 = 0, c2 = 1, c3 = 1;
while (c2 <= n && c3 <= n){
c1 = c1 + 1;
c2 = c2 + 1;
if (c2 > n && c3 < n){
c2 = 1;
c3 = c3 + 1;
}
}
Consola.imprimir(c1);
}
1.4.

void rutina2(int vec[ ], int n, int dato){

int i = 1, j = n, k;
do {
k = (i + j) / 2;
if (vec[k] <= dato)
i = k + 1;
else
j = k - 1;
} while (i <= j);
}
1.5.

int funcion3 ( ){
int n, cont, prod;
Consola.imprimir(Ingrese un nmero entero: )
n = Consola.leerEntero( );
cont = 0;
prod = 3;
while (prod <= n){
cont = cont + 1;
prod = prod * prod;
}
return cont;
}

2. Restriccin: se tiene una lista ligada simple no ordenada de nmeros enteros.

La comprensin de los algoritmos (mtodos) se facilita teniendo en cuenta el

siguiente diagrama de clases:

Nodo
- info: int
- liga: Nodo

+ Nodo( )
+ setInfo(int)
+ getInfo( ): int
+ setLiga(Nodo)
+ getLiga( ): Nodo

ListaLigada
- cab: Nodo
+ ListaLigada( )
+ // mtodos convencionales
+ invertirLista1( )
+ invertirLista2( )
+ eliminar(int)

Consola
<<abstract>>

+ static leerEntero( ): int

+ static leerReal( ): double
+ static leerCaracter( ): char
+ static leerCadena( ): String
+ static imprimir(String)

2.1.
public void invertirLista1( ){
int temp;
Nodo p, q, r;
q = cab;
while (q.getLiga() != null)
q = q.getLiga( );
for(p = cab; p != q && q.getLiga( ) != p; p = p.getLiga( )){
temp = p.getInfo( );
p.setInfo(q.getInfo( ));
q.setInfo(temp);
for(r = p; r.getLiga( )!= q; r = r.getLiga( ));
q = r;
}
}

2.2.
public void invertirLista2( ){
Nodo p = cab, q;
cab = null;
while (p != null){
q = p.getLiga( );
p.setLiga(cab);
cab = p;
p = q;
}
}
2.3.
public void eliminar(int dato){ //1
boolean sw = false;
Nodo p, ant = null, n = null;
p = cab;
while (p!= null && !sw){ //2
if (p.getInfo( ) == dato)
sw = true;
else { //3
ant = p;
p = p.getLiga( );
} //3
} //2
if (sw){ //4
if (p == cab){ //5
cab = p.getLiga( );
p.setLiga(null);
p = null;
} //5
else{ //6
n = p.getLiga( );
ant.setLiga(n);
p.setLiga(null);
p = null;
} //6
Consola.imprimir(dato + " eliminado");
} //4
else
Consola.imprimir(dato + " no existe");
} //1

3. Restriccin: num es un entero positivo.

3.1.
void proceso1 (int num){
int i, k;
i = 1;
while (i <= num){
k = i;
while (k <= num)
k++;
k = 1;
while (k <= i)
k++;
i++;
}
}
3.2.
void proceso2 (int num){
int i, k, t;
i = 1;
while (i <= num - 1){
k = i + 1;
while (k <= num){
t = 1;
while (t <= k)
t++;
k++;
}
i++;
}
}
3.3.
void proceso3 (int num){
int i = 1, k;
while (i <= num){
k = num - i;
while (k >= 1)
k = k / 5;
i++;
}
}

4. Restriccin: val es una potencia de 2 (v.g. 2, 4, 8, 16, 32, )

void algoritmo(int val ){

int i;
i = 2;
while (i <= val)
i *= 2;
}
B. Responder:
5.

Cul es la complejidad de un mtodo que lee una lista encadenada de n

elementos?

6.

Liste, por orden de eficiencia (comenzando por el menos eficiente y

finalizando con el ms), los rdenes de magnitud de un algoritmo
estudiados hasta el momento.

7.

Adems de los estudiados, consulte otros rdenes de magnitud que se

puedan presentar.

8.

Ordnense las siguientes funciones de acuerdo con su velocidad de

crecimiento:
a) n, b) , c) log n, d) log log n, e) log n2, f) n/log n, g) 2 ,
h) (1/3)n, i) (3/2)n, j) 17.

C. Para cada uno de los siguientes problemas, plantee el algoritmo respectivo

(puede ser en seudocdigo, en Java o en C#) y calcule su complejidad.
Realice todos los supuestos semnticos que considere necesarios,
relacionados con la estructura de la clase a la que pertenece el algoritmo (o
mtodo), reutilizacin de componentes (por ejemplo la clase Math de Java),
etc.
9.

Ordenar un vector por alguno de los mtodos conocidos.

10. Buscar un elemento en un vector desordenado (bsqueda secuencial).

11. Buscar un elemento en un vector ordenado (bsqueda binaria).
12. Multiplicar dos matrices cuadradas.

13. Multiplicar dos matrices no necesariamente cuadradas.

14. Invertir una lista ligada simple: a) cambiando el sentido de los

apuntadores y b) sin cambiar el sentido de los apuntadores, es decir,

intercambiando contenidos entre nodos. Cul de los dos algoritmos es
mejor y por qu? (Ver ejercicios 2.1 y 2.2)
15. Intercalar dos listas ligadas simples del mismo tipo pero de diferente

tamao.
16. Crear una pila y una cola con los elementos de un vector. Mostrar la pila y

retornar la cola.
17. Crear una pila y una cola con los elementos de una lista ligada simple.

Mostrar la cola y retornar la pila.

18. Mostrar el n-simo trmino de la serie de Fibonacci.
19. Calcular las combinaciones de m elementos tomados n a la vez.

Recordar que C(m, n) = m! / n! (m - n)!

20. Se dice que un nmero entero es "perfecto" si sus factores, incluyendo el 1

pero excluyendo el nmero mismo, suman igual que el nmero. Por

ejemplo 6 y 28 son nmeros perfectos porque:
6 = 1 + 2 + 3 y 28 = 1 + 2 + 4 + 7 + 14.
Considere la clase NumeroPerfecto con un atributo num de tipo entero.
Para dicha clase, escriba la funcin esPerfecto( ), que determina si el
atributo num corresponde a un nmero perfecto. Utilice sta funcin en un
programa que determine e imprima los nmeros perfectos entre los lmites
inf y sup, donde sup > inf > 0. Imprimir los factores de cada nmero
perfecto para confirmar que de verdad lo es.