Unidad II: Análisis y Diseño de los Algoritmos

INDICE DEL CONTENIDO

INTRODUCCION DE LA UNIDAD ................................................................................................................4

1) Complejidad. Eficiencia de un algoritmo ....................................................................................................6
2) Análisis de los casos Mejor, Medio y Peor .................................................................................................7
3) Operaciones elementales .........................................................................................................................10
4) Notación asintótica: Orden de un algoritmo ............................................................................................11
5) Análisis de las estructuras de control .......................................................................................................11
6) Recursión. Algoritmos recursivos. Árboles de recursión ..........................................................................12
7) Demostraciones por inducción. Cómo saber cuando un procedimiento es correcto ..............................12
8) Técnicas de diseño de algoritmos: Divide y vencerás, Métodos ávidos o voraces, Método de Retroceso
(backtracking), Programación dinámica y Método Branch and Bound ...........................................................13
BIBLIOGRAFIA ..............................................................................................................................................14

3
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

INTRODUCCION DE LA UNIDAD

Imagen obtenida en http://www.iit.upcomillas.es/organizacion/Lineas_investigacion.php.es?linea=71

Con el avance de la tecnología se encuentran aplicaciones cada vez más robustas y

eficientes, desarrolladas para diferentes ambientes, ya sea local o web. Para desarrollar
esas aplicaciones se requieren algoritmos que estén acorde al medio en que se
desempeñan. Surgen varias preguntas interesantes, ¿Son iguales todos los algoritmos?
¿Se puede aplicar un algoritmo a cualquier solución? ¿Cuál es el algoritmo indicado para
una solución X?

En esta unidad se responderán las preguntas planteadas en el párrafo anterior,

describiendo conceptos relacionados con el análisis y diseño de los algoritmos, entre los
cuales se encuentran: los aspectos a tomar en consideración para realizar el análisis y las
herramientas que se utilizan al momento de diseñar.

Nuestra principal meta es Diseñar algoritmos eficientes.

4
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

Al terminar esta unidad los/as participantes estarán en capacidad de:

5
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

DESARROLLO DEL CONTENIDO

1) Complejidad. Eficiencia de un algoritmo

De acuerdo al Manual de análisis y diseño de algoritmos. Versión 1.0, publicado por

el INACAP en el 2003.

Un algoritmo es eficiente cuando logra llegar a sus objetivos planteados utilizando la

menor cantidad de recursos posibles, es decir, minimizando el uso memoria, de pasos
y de esfuerzo humano.

Un algoritmo es eficaz cuando alcanza el objetivo primordial, el análisis de resolución

del problema se lo realiza prioritariamente. Puede darse el caso de que exista un
algoritmo eficaz pero no eficiente.

El análisis de los algoritmos dependerá de si se trabaja con máquinas de un solo

procesador o de varios de ellos. El análisis de esta unidad se basará en los algoritmos
para máquinas de un solo procesador que ejecutan una instrucción y luego otra.

El uso eficiente de los recursos, suele medirse en función de dos parámetros: el

espacio, es decir, memoria que utiliza, y el tiempo, lo que tarda en ejecutarse. Ambos
representan los costes que supone encontrar la solución al problema planteado
mediante un algoritmo. Dichos parámetros van a servir además para comparar

6
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

algoritmos entre sí, permitiendo determinar el más adecuado de entre varios que
solucionan un mismo problema.1

2) Análisis de los casos Mejor, Medio y Peor

Para verificar el proceso de analizar un algoritmos en los casos Mejor, Medio y Peor, a
continuación un fragmento del libro Técnicas de Diseño de Algoritmos

Es importante hacer notar que el comportamiento de un algoritmo puede cambiar

notablemente para diferentes entradas (por ejemplo, lo ordenados que se encuentren
ya los datos a ordenar). De hecho, para muchos programas el tiempo de ejecución es
en realidad una función de la entrada específica, y no sólo del tamaño de ésta.

Para un mismo algoritmo se pueden estudiar los tres casos: caso peor, caso mejor y
caso medio. El caso mejor corresponde a la traza (secuencia de sentencias) del
algoritmo que realiza menos instrucciones. Análogamente, el caso peor corresponde a
la traza del algoritmo que realiza más instrucciones. Respecto al caso medio,
corresponde a la traza del algoritmo que realiza un número de instrucciones igual a la
esperanza matemática de la variable aleatoria definida por todas las posibles trazas
del algoritmo para un tamaño de la entrada dado, con las probabilidades de que éstas
ocurran para esa entrada.

Como se puede observar no es necesario conocer el propósito del algoritmo para

analizar su tiempo de ejecución y determinar sus casos mejor, peor y medio, sino que
basta con estudiar su código. Suele ser un error muy frecuente el determinar tales
casos basándose sólo en la funcionalidad para la que el algoritmo fue concebido,
olvidando que es el código implementado el que los determina.

1 Técnicas de diseño de algoritmos [PDF], cap. 1 Complejidad de los algoritmos

7
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

Laboratorio tomado del libro Fundamentos de Programación

Se quiere analizar el comportamiento del algoritmo de ordenar por el método de
inserción en forma experimental. Para esto seguiremos los siguientes pasos:
1. Codificar el algoritmo.
2. Crear una instancia ordenada en forma ascendente.
3. Tomar el tiempo de proceso para diferentes tamaños de instancias.
4. Repetir el proceso para una instancia ordenada en forma descendente.
5. Luego para una instancia generada aleatoriamente.
6. Tabular los datos.
7. Interpretar los resultados.
Para realizar este experimento construimos el siguiente programa Java:
import java.util.*;
public class Isort {
/**
* Rutina Principal para la prueba experimental del
* programa de ordenar por el método de inserción
*
* @param args
* 0 crear las instancias en forma descendente
* 1 crear las instancias en forma ascendente
* 2 crear las instancias en forma aleatoria
*/
public static void main(String[] args) {
int opcion = Integer.parseInt(args[0]);
int instanciaMaxima = 1000000;
long tiempoInicio, tiempoFin, tiempoTotal;
for (int i = 10; i < instanciaMaxima; i = i * 10) {
Arreglo arreglo = new Arreglo(opcion, i);
tiempoInicio = System.currentTimeMillis();
arreglo.Ordena();
tiempoFin = System.currentTimeMillis();
tiempoTotal = tiempoFin - tiempoInicio;
System.out.println("Tama~no de la instancia " + i
+ " Tiempo de proceso " + tiempoTotal);
}
}
}
class Arreglo {

8
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

int[] t = new int[100000];

Random generador = new Random();
int n;

Arreglo(int opcion, int n) {

this.n = n;
for (int i = 0; i < n; i++) {
switch (opcion) {
case 0:
t[i] = i;
break;
case 1:
t[i] = 10000 - i;
break;
case 2:
t[i] = generador.nextInt(10000);
}
}
}
void Ordena() {
int x, j;
for (int i = 1; i < n; i++) {
x = t[i];
j = i - 1;
while ((j > 0) && (x < t[j])) {
t[j + 1] = t[j];
j = j - 1;
t[j + 1] = x;
}
}
return;
}
}
El resultado de los tiempos de ejecución, en mili segundos, obtenidos en la prueba del
programa se ven en el cuadro 1.1.

Como se ve el peor caso es cuando la instancia que creamos está ordenada en forma
descendente. El caso medio se da cuando el vector está ordenado aleatoriamente. En
diferentes ejecuciones del programa veremos que el tiempo de proceso que se obtiene
en el caso medio varía. Esto se debe a que los datos que se generan no están en el

9
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

mismo orden. Situación que no se da en las otras instancias generadas. Una buena
aplicación de este código se da en los casos en que los conjuntos de datos a los que
vamos aplicar el método, están casi totalmente ordenados.
Tamaño Ordenada Ordenada Instancia
Instancia Ascendente Descendente Aleatoria

10 0 0 0
100 0 0 0
1000 0 20 10
10000 0 1722 861
100000 10 237622 110229

Cuadro 1.1: Tiempo de ejecución en milisegundos

Para profundizar el aprendizaje del análisis de los casos Mejor, Medio y Peor, seguir
leyendo el material complementario Cap1 Complejidad de los Algoritmos del libro
Técnicas de Diseño de Algoritmos.

3) Operaciones elementales
Es una operación cuyo tiempo de ejecución está acotado por una constante que
solo depende de una implementación particular como ser la máquina, el lenguaje
de programación, etc.

En el caso de la suma de elementos de un vector lo que deseamos medir es la

cantidad de sumas realizadas para resolver el problema y las operaciones de
comparación necesarias para implementar una solución, se consideran
operaciones elementales.2

2 Terán Pomier, Jorge Humberto, (2006). Fundamentos de la programación. Facultad de Ciencias

Puras y Naturales de la Universidad Mayor de San Andrés. La Paz, Bolivia. [PDF], p. 18

10
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

4) Notación asintótica: Orden de un algoritmo

Como expresa el capítulo 1 del libro Técnicas de Diseño de Algoritmos

1. La utilización de las cotas asintóticas para comparar funciones de tiempo de
ejecución se basa en la hipótesis de que son suficientes para decidir el mejor
algoritmo, prescindiendo de las constantes de proporcionalidad. Sin embargo, esta
hipótesis puede no ser cierta cuando el tamaño de la entrada es pequeño.
2. Para un algoritmo dado se pueden obtener tres funciones que miden su tiempo de
ejecución, que corresponden a sus casos mejor, medio y peor, y que denominaremos
respectivamente Tm(n), T1/2(n) y Tp(n). Para cada una de ellas podemos dar tres
cotas asintóticas de crecimiento, por lo que se obtiene un total de nueve cotas para el
algoritmo.
3. Para simplificar, dado un algoritmo diremos que su orden de complejidad es O(f) si
su tiempo de ejecución para el peor caso es de orden O de f, es decir, Tp(n) es de
orden O(f). De forma análoga diremos que su orden de complejidad para el mejor caso
es Ω(g) si su tiempo de ejecución para el mejor caso es de orden Ω de g, es decir,
Tm(n) es de orden Ω(g).
4. Por último, diremos que un algoritmo es de orden exacto θ(f) si su tiempo de
ejecución en el caso medio T1/2(n) es de este orden.

5) Análisis de las estructuras de control

a) Las estructuras secuenciales: El análisis de estas estructuras muestra que el

resultado de un proceso es independiente del otro, debido a que cada proceso
consume el tiempo que tiene asignado.
b) Ciclos For: Para analizar las estructura de control de Ciclo For hay que tomar
en consideración dos factores: 1 Si la variable subindicada toma un tiempo
constante y no depende del subíndice, entonces la secuencia se repetirá tantas
veces como lo indique el parámetro To, y 2 Si la variable subindicada toma un
tiempo que no es constante y depende del subíndice, el resultado se calcula
utilizando una sumatoria.
c) Ciclos While y Repeat: Estas estructuras son más fáciles, debido a que no se
tiene el tiempo exacto en que termine.

11
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

6) Recursión. Algoritmos recursivos. Árboles de recursión

Recursión es la forma en la cual se especifica un proceso basado en su propia

definición.

Un algoritmo recursivo es un algoritmo que expresa la solución de un problema en

términos de una llamada a sí mismo. La llamada a sí mismo se conoce como llamada
recursiva o recurrente.

Árboles de recursión por su naturaleza los árboles se definen como recursivos.

Árboles y Recursividad

7) Demostraciones por inducción. Cómo saber cuando un

procedimiento es correcto

La inducción matemática es como recursión y es aplicable a una variedad de

problemas.

La inducción proporciona una forma útil de pensar en diseño de algoritmos, ya que lo

estimula a pensar en resolver un problema, construyendo a partir de pequeños
subproblemas.

Para profundizar estos conceptos consultar el material complementario Recursion and

Induction [PPT] de la autora Sara Baase

12
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

8) Técnicas de diseño de algoritmos: Divide y vencerás, Métodos ávidos

o voraces, Método de Retroceso (backtracking), Programación
dinámica y Método Branch and Bound

Técnica de Diseño de Algoritmos

Método
Métodos Método de Branch and
Divide y Programación
Ávidos o Retroceso Bound
Venceras Dinámica
Voraces (backtracking) (Ramificación
y Poda)

En el siguiente enlace encontrarás más detalles con respecto a estas técnicas

y en el capítulo 5 del material complementario de INACAP, el cual se encuentra en la
unidad 01.

http://en.wikibooks.org/wiki/Algorithms

13
Agustina De los Santos Rosario y Felix Ferreiras
Unidad II: Análisis y Diseño de los Algoritmos

BIBLIOGRAFIA

Algorithms. Obtenido en http://en.wikibooks.org/wiki/Algorithms

Árboles y recursividad. Obtenido en http://es.scribd.com/doc/38545847/18/Arboles-y-

recursividad

Baase, Sara, (2001). Computer Algorithms: An Introduction to Design & Analysis.

Addison-Wesley. [PPT]
Técnicas de diseño de algoritmos [PDF]

Terán Pomier, Jorge Humberto, (2006). Fundamentos de la programación. Facultad de

Ciencias Puras y Naturales de la Universidad Mayor de San Andrés. La Paz, Bolivia.
[PDF]

14
Agustina De los Santos Rosario y Felix Ferreiras