Universidad Católica de la Santísima Concepción Mariella Gutiérrez ...

Algoritmos y Estructuras de Datos
1. Conceptos Básicos
1.1. Algoritmo
¿Qué es un algoritmo?
“Un algoritmo es un conjunto de instrucciones sencillas, claramente especificado, que se debe seguir para
resolver un problema.” Weiss, M.A.
“Secuencia finita de instrucciones, cada una de las cuales tiene un significado preciso y puede ejecutarse con
una cantidad finita de esfuerzo en un tiempo finito”. Aho, A.V.
De manera adicional los algoritmos deben cumplir con los siguientes criterios:
Las instrucciones deben ser claras, concisas y lo suficientemente básica para que se pueda realizar en
forma manual (al menos en teoría).
En todos los casos, el algoritmo termina después de ejecutar una cantidad finita de instrucciones.
El algoritmo cumple al menos una tarea, produce al menos un valor, o ambos.
Un algoritmo es una técnica de resolución de problemas apropiada para ponerse en práctica mediante un
programa computacional, pero no está atado a la implementación.
Ejemplo: Algoritmo para calcular la suma de los enteros que van de 1 a n.
Resolución en lenguaje natural:
a. Inicialice un contador con el valor 1.
b. Agregue a una variable acumuladora el valor que contiene el contador.
c. Incremente el contador en 1.
d. Repita los pasos b y c hasta que el contador sea mayor que n.
Resolución en pseudolenguaje:
a. Contador = 1
b. Mientras Contador

Suma2 (int n)
{ int resulta;
}
resulta = n*(n+1)/2;
return(resulta);
Cuando damos una solución algorítmica a un problema debemos preguntarnos:
¿La solución propuesta es la única forma de solucionar el problema?
¿Existe una forma más sencilla de resolver el problema?
¿Es la forma óptima de resolver el problema?
¿Funciona correctamente con cualquier cantidad de trabajadores?
Lo que se quiere lograr es dar solución a un problema a través de un programa computacional. Esta tarea es
compleja y requiere de varios pasos:
1. Formulación y especificación del problema: fase de análisis de necesidades
2. Diseño de la solución
Diseñar las estructuras de datos: debes ser diseñanas de manera que faciliten la programación.
Formular el algoritmo en Seudocódigo: Cada instrucción en seudocódigo describe tareas que el
programador pondrá en funcionamiento mediante una o más instrucciones del lenguaje.
Análisis del diseño: Se divide en tres fases: (1) Determinar factibilidad de la solución: facilidad,
necesidad de memoria, desempeño, etc. (2) Revisar y convalidar la descripción hecha en seudocódigo.
(3) Análisis de la complejidad del algoritmo: medida de la cantidad de trabajo realizada.
Otros criterios de análisis: claridad, mantenimiento, portabilidad, uso de recursos.
3. Implantación de la solución: traducción del algoritmo en seudocódigo a un lenguaje de programación.
Implica escoger el lenguaje apropiado.
4. Prueba: Consta de dos partes: (1) Idear un conjunto de pruebas que intenten que el programa falle. (2)
Depuración: identificar qué está mal y arreglarlo, para hacer nuevamente pruebas.
5. Documentación: incorporar al código todos los comentarios y explicaciones que lo hagan entendible a
cualquier programador.
1. 2. Análisis de Algoritmos
La eficiencia de un determinado algoritmo depende de la maquina, y de otros factores externos al propio diseño.
Para comparar dos algoritmos sin tener en cuenta estos factores externos se usa la complejidad. Esta es una
medida informativa del tiempo de ejecución de un algoritmo, y depende de varios factores:
• Los datos de entrada del programa. Dentro de ellos, lo más importante es la cantidad, su disposición, etc.
• La calidad del código generado por el compilador utilizado para crear el programa.
• La naturaleza y rapidez de las instrucciones empleadas por la máquina y la propia máquina.
• La propia complejidad del algoritmo base del programa.
Tipos de análisis
• Peor caso (usualmente): T(n) = Tiempo máximo necesario para un problema de tamaño n
• Caso medio (a veces): T(n) = Tiempo esperado para un problema cualquiera de tamaño n
Requiere establecer una distribución estadística
• Mejor caso (engañoso)
Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela
Facultad de Ingeniería Docente Área Informática

En cualquier caso se define T(n) como el tiempo de ejecución del peor caso, es decir, el máximo valor del
tiempo de ejecución para las entradas de tamaño n.
Por ejemplo algunos programas pueden tener un tiempo de ejecución. T(n)=Cn 2 , donde C es una constante que
engloba las características de la máquina y otros factores.
Las unidades de T(n) se dejan sin especificar, pero se puede considerar a T(n) como el número de
instrucciones ejecutadas en un computador idealizado y es lo que se entiende por complejidad.
Base Matemática
Definición 1: T(n) = O(f(n)), si existen constantes c y n0 tales que T(n) =n0
Definición 2: T(n) = Ω(g(n)), si existen constantes c y n0 tales que T(n) >= cg(n) cuando n>=n0
Definición 3: T(n) = Θ(h(n)) si y solo si T(n) = O(h(n)) y T(n) = Ω(h(n))
Definición 4: T(n) = o(p(n)) si T(n) = O(p(n)) y T(n) ? Θ(p(n))
El objetivo de estas definiciones es establecer un orden relativo entre dos funciones. Generalmente esto se
hace en base a su tasa de crecimiento. No tiene sentido decir que f(n) < g(n).
Ejemplo: Sea f(n) = 1000n y g(n)= n 2 . Se tiene que f es mayor que g para valores pequeños de n, pero n 2 crece
con una tasa mayor, así g será finalmente la función mayor. El punto de cambio es n = 1000.
2500000
2000000
1500000
1000000
500000
0
200 400 600 800 1000 1200 1400
n
Si se considera la definición 1: T(n) = O(f(n)), si existen constantes c y n0 tales que T(n) =n0
Suponga T(n)= 1000n y f(n)= n 2 , n0=1000 y c = 1, entonces 1000n =1000.
Se puede decir que T(n) = O(n 2 ), es decir, el tiempo de ejecución T es del "orden n cuadrada". En la definición1
se establece una cota superior para el tiempo de ejecución T(n).
La definición 2 establece una cota inferior para el tiempo de ejecución.
En la definición 3 se dice que el tiempo de ejecución es exactamente igual a una función.
La definición 4 establece una cota superior que nunca se alcanza.
Ejemplo: f(n)= n 2 y g(n)= n 3 , la tasa de crecimiento de g es mayor que f si consideramos los enteros positivos.
Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela
Facultad de Ingeniería Docente Área Informática
f(n)
g(n)

600
500
400
300
200
100
0
1 2 3 4 5 6 7 8
Se puede decir que: f(n)=O(g(n)) y g(n)=Ω(f(n))
Regla1: Si T1(n)=O(f(n)) y T2(n)=O(g(n)), entonces
a) T1(n) + T2(n) = máx(O(f(n)),O(g(n))),
b) T1(n) * T2(n) = O(f(n)*g(n))
Regla2: Si T(x) es un polinomio de grado n, entonces
a) T(x) = O(x n )
n
Regla3: log k n = O(n) para cualquier k constante. Esto indica que los logaritmos crecen muy lentamente.
Ejemplo: f(n)=n 2 y g(n)=n, entonces g(n) =n0, entonces O(f(n) + g(n)) = O(f(n)), es decir,
O(n 2 + n) = O(n 2 )
Ejemplo: f(n)=c y g(n)= n 2 , f(n)*g(n)=cn 2 entonces si c es una constante positiva O(f(n)*g(n))=O(g(n)), es decir,
O(2n 2 ) = O(n 2 ) si c=2.
Tasas de crecimiento típicas
Se dice que O(f(n)) define un "orden de complejidad". Se puede definir una jerarquía de órdenes de
complejidad, dado por la siguiente tabla:
Función Nombre
c orden constante
log n orden logarítmico
log 2 n orden logarítmica cuadrada
n orden lineal
n log n
n 2 orden cuadrático
n a orden polinomial (a > 2)
2 n orden exponencial
n! orden factorial
Impacto Práctico
Suponga que tiene un problema que se puede resolver con algoritmos de diferentes complejidades, y que se
dispone de 1000 segundos para resolver el problema. Interesa responder a:
Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela
Facultad de Ingeniería Docente Área Informática
g(n)
f(n)

• ¿Qué tamaño del problema se puede resolver?
• ¿Qué sucede si se dispone de una máquina 10 veces más rápida sin costo adicional?
• ¿Qué tamaño de problema se puede resolver?
T(n)=O(f(n))
Tamaño máx del problema
para 10 3 seg
Tamaño máx del problema
para 10 4 seg
100n 10 100 10
5n 2 14 45 3.2
n 3 /2 12 27 2.3
2 n 10 13 1.3
Reglas de cálculo de complejidad de T(n)
Incremento en el tamaño
máximo del problema
• El tiempo de ejecución de cada sentencia simple, por lo común puede tomarse como O(1).
• El tiempo de ejecución de una secuencia de proposiciones se determina por la regla de la suma. Es el
máximo tiempo de ejecución de una proposición de la sentencia.
• Para las sentencias de bifurcación (IF, CASE) el orden resultante será el de la bifurcación con mayor
orden.
• Para los bucles es el orden del cuerpo del bucle sumado tantas veces como se ejecute el bucle.
• El orden de una llamada a un subprograma no recursivo es el orden del subprograma.
Reglas Prácticas
Aunque no existe una receta que siempre funcione para calcular la complejidad de un algoritmo, si es posible
tratar sistemáticamente una gran cantidad de ellos, basándonos en que suelen estar bien estructurados y
siguen pautas uniformes. Los algoritmos bien estructurados combinan las sentencias de alguna de las formas
siguientes:
• secuencia (;)
• decisión (IF ... THEN ... ELSE ...)
• bucles (WHILE, REPEAT, FOR)
• llamadas a procedimientos
1. Sentencias sencillas
Corresponden a las sentencias de asignación, entrada/salida, etc. siempre y cuando no trabajen sobre variables
estructuradas cuyo tamaño este relacionado con el tamaño N del problema. La inmensa mayoría de las
sentencias de un algoritmo requieren un tiempo constante de ejecución, siendo su complejidad O(1).
2. Secuencia (;)
La complejidad de una serie de elementos de un programa es del orden de la suma de las complejidades
individuales, aplicándose las operaciones arriba expuestas.
3. Decisión (IF ... THEN ... ELSE ... END)
La condición suele ser de O(1), complejidad a sumar con la peor posible, o bien en la rama THEN o en la rama
ELSE. En decisiones múltiples (ELSIF, CASE), se tomara la peor de las ramas.
Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela
Facultad de Ingeniería Docente Área Informática

4. Bucles (WHILE, REPEAT, FOR)
En los bucles con contador explícito, podemos distinguir dos casos, que el tamaño N forme parte de los límites
o que no. Si el bucle se realiza un número fijo de veces, independiente de N, entonces la repetición sólo
introduce una constante multiplicativa que puede absorberse.
Ejemplos
Ejemplo: K constante
FOR i:= 1 TO K DO
algo_de_O(1) ; => K*O(1) = O(1)
END;
Ejemplo: Si el tamaño N aparece como límite de iteraciones
FOR i:= 1 TO N DO
algo_de_O(1) => N * O(1) = O(n)
END;
Ejemplo: Ciclo for anidados
FOR i:= 1 TO N DO
FOR j:= 1 TO N DO => Se tiene N * N * O(1) = O(n 2 )
algo_de_O(1)
Ejemplo: Ciclo for anidados
FOR i:= 1 TO N DO
FOR j:= 1 TO K DO => Se tiene N * K * O(1) = O(N)
algo_de_O(1)
Ejemplo: Ciclo for anidados
FOR i:= 1 TO N DO
FOR j:= 1 TO i DO
algo_de_O(1)
El bucle exterior se realiza N veces, mientras que el interior se realiza 1, 2, 3, ... N veces respectivamente.
1 + 2 + 3 + ... + N = N*(1+N)/2 -> O(n 2 )
A veces aparecen bucles multiplicativos, donde la evolución de la variable de control no es lineal (como en los
casos anteriores)
Ejemplo:
c:= 1;
WHILE c < N DO
algo_de_O(1)
c:= 2*c;
El valor inicial de "c" es 1, siendo "2 k " al cabo de "k" iteraciones. El número de iteraciones es tal que
2 k >= N => k = log2 N [el entero inmediato superior] y por tanto, la complejidad del bucle es O(log n).
Ejemplo: c:= N;
WHILE c > 1 DO
algo_de_O(1)
c:= c/2;
Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela
Facultad de Ingeniería Docente Área Informática

Un razonamiento análogo nos lleva a log2(N) iteraciones y, por tanto, a un orden O(log n) de complejidad.
Ejemplo: FOR i:= 1 TO N DO
c:= i;
WHILE c > 0 DO
algo_de_O(1)
c:= c/2;
Tenemos un bucle interno de orden O(log n) que se ejecuta N veces, luego el conjunto es de orden O(n log n)
5. Llamadas a procedimientos
La complejidad de llamar a un procedimiento viene dada por la complejidad del contenido del procedimiento en
sí. El coste de llamar no es sino una constante que podemos obviar inmediatamente dentro de nuestros análisis
asintóticos. El cálculo de la complejidad asociada a un procedimiento puede complicarse notablemente si se
trata de procedimientos recursivos. Es fácil que tengamos que aplicar técnicas propias de la matemática
discreta, tema que queda fuera de los límites de esta nota técnica.
Propiedades
n
1. ∑ 2 i = 2 n+1 -1 4. log (a b ) = b log a 7. logb x = logc x / logc b
i=0
n n
2. ∑ 2 i = ∑ 2 i - 2 0 = 2 n+1 -1 - 1= 2 n+1 – 2 5. log (ab) = log a + log b
i=1 i=0
n
3. ∑ i ≈ n 2 /2 6. log (a/b) = log a – log b
i=1
Ejercicio
Problema: Calcular números de Fibonacci
La secuencia Fibonacci se define como: 0, 1, 1, 2, 3, 4, 8, 13, ….
Se inicia F0 = 0 ; F1 = 1; y el siguiente número se calcula sumando los dos anteriores. Por ejemplo:
Entonces:
F(3) = F(2) + F(1) = 1 + 1 = 2
F(4) = F(3) + F(2) = 2 + 1 = 3
F0 = 0
F1 = 1
Fn = Fn-1 + Fn-2, donde n >=2
Comprensión del Problema:
• Se debe diseñar e implementar una función que acepte un entero no negativo como argumento n y
devuelva el valor de F(n).
• Si se le entrega un valor negativo como argumento la función debe hacer algo razonable.
Estructura de datos:
Se usarán variables enteras para calcular cada número de Fibonacci.
Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela
Facultad de Ingeniería Docente Área Informática

Seudocódigo
Si se utiliza la definición formar de la serie de Fibonacci, se tiene:
Versión 1:
Fib (n)
If n = 0
Return (0);
If n = 1
Return (1);
For i = 2 to n
fib = fmin1 + fmin2;
Actualizar fmin1 y fmin2;
Return (fib)
Este seudocódigo presenta algunos problemas como:
• No se han inicializado variables.
• No resuelve el caso de números negativos.
• No se explicita como se actualiza fmin1 y fmin2.
Versión 2:
Fib (n)
If n < 0
Return (-1);
If n = 0
Return (0);
If n = 1
Return (1);
fmin1 = 0;
fmin2 = 1;
For i = 2 to n
fib = fmin1 + fmin2;
fmin2 = fmin1;
fmin1 = fib;
Return (fib)
Análisis del algoritmo:
Fib (n)
If n < 0
Return (-1); O(1)
If n = 0
Return (0); O(1)
If n = 1
Return (1); O(1)
fmin1 = 0; O(1)
fmin2 = 1; O(1)
For i = 2 to n El ciclo se ejecuta (n-1) veces. Se tiene 3*(n-1) => 3n => O(n)
fib = fmin1 + fmin2; O(1)
fmin2 = fmin1; O(1)
fmin1 = fib; O(1)
Return (fib) O(1) Resultado: El algoritmo es de orden lineal, O(n)
Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela
Facultad de Ingeniería Docente Área Informática

Implementación
El algoritmo en seudocódigo permite hacer una traducción directa a lenguaje C.
int Fib ( int n)
{
int i;
int fibn, fib1, fib2;
}
If (n < 0)
return (-1);
If (n == 0)
return (0);
If (n == 1)
return (1);
fibn = 0;
fib1 = 0; /* F(n-2) */
fib2 = 1; /* F(n-1) */
for (i = 2; I

Ejercicios
n
1. Escriba un algoritmo para calcular ∑ i 3
Evaluar el orden del algoritmo i=1
2. Analice el tiempo de ejecución de los siguientes algoritmos para calcular x n :
Algoritmo 1:
función potencia(x,n) {donde x y n son enteros positivos}
comienzo
si n = 0 entonces
potencia = 1;
sino
si n=1 entonces
potencia = x
sino
potencia = x
para i = 2 hasta n haga
potencia = potencia * x
fin para
fin
fin
fin {potencia}
Algoritmo 2:
función potencia(x,n) {donde x y n son enteros positivos}
comienzo
si n = 0 entonces
potencia = 1;
sino
si n=1 entonces
potencia = x
sino
si n es par entonces
potencia = potencia(x*x, n div 2)
sino
potencia = potencia( x * x, n div 2) * x
fin
fin
fin
fin {potencia}
3. Escriba un algoritmo recursivo para visualizar los dígitos de un número entero no negativo.
Evaluar el orden del algoritmo.
Universidad Católica de la Santísima Concepción Mariella Gutiérrez Valenzuela
Facultad de Ingeniería Docente Área Informática