Este documento presenta un resumen de los conceptos clave relacionados con algoritmos. Define un algoritmo como un procedimiento ordenado para resolver un problema utilizando datos de entrada precisamente definidos y un número finito de instrucciones. Explica que los algoritmos deben terminar después de realizar un número finito de operaciones y demostrar que resuelven el problema. También cubre temas como la eficiencia de los algoritmos, diferentes modelos computacionales, tipos de instrucciones y varios ejemplos de algoritmos.

1. Capítulo 2
Algoritmos

3. Problema
real
Planteamiento
Formal
¿Presenta Solución?
ALGORITMO
Demostración
de que funciona
Estudio de su
eficiencia
Lógica
Otra vez lógica
Complejidad

4. Definición de Algoritmo:
Se define como un procedimiento constructivo
para la resolución de un problema y consta de:
1. Datos de entrada (precisamente definidos),
2. una cantidad finita y ordenada de
instrucciones que
3. aplicadas a los datos de entrada y después de
realizar una cantidad finita de operaciones
obtiene una solución del problema.

5. Resaltamos
• Datos de entrada.
• Operaciones básicas.
• El algoritmo termina.
• Hay que demostrar que resuelve el
problema.
• Hay que estudiar su eficiencia.

6. Modelo computacional
• Determinar los tipos de datos que admite
como entrada.
• Determinar las operaciones básicas (y
construidas por medio de ellas, más
complejas) que puede hacer con dichos
datos.

7. Nuestro Modelo Computacional
RAM
• Datos de entrada: números enteros.
• Operaciones básicas:
– Asignaciones: x:=2;
– Operaciones de suma (+), resta (-),
multiplicación (·, ×) y división entera (2/3, 2
mod 3).
– Comparaciones (x < y, x>y, x ≥y, x≤y, x≠y,
x=y)

8. Ejemplos
Asignaciones x:=5
y:=3
Sumas: x+y (=8)
Restas: x-y (=2)
Cociente: x/y (=1)
Resto: x mod y (=2)
Comparaciones: x>y
≠ ≤ ≥ <

9. Instrucciones
• Condicionales:
• If (condición1, condición2,…) then (instrucciones
1) [else (instrucciones 2)]
– If x>y then m:=x+y
• Bucles:
• For i=a to b (i empieza en a, termina
en b y va de uno en uno)
Instrucciones
• While (condición) (el posible contador no
cambia)
Instrucciones

10. Máximo de dos números
Entrada: a, b (dos números enteros)
If a>b then m:=a else m:=b
Salida: m

11. Máximo de una lista
Entrada: a_1,…, a_n (una pequeña trampa)
m:=a_1
For i=2 to n
If a_i>m then m:=a_i
Salida: m

12. Suma de los elementos de una lista
Entrada: a_1,…, a_n
Suma:=a_1
For i=2 to n
Suma:=Suma+a_i
Salida: Suma

13. Suma de los positivos
Entrada: a_1,…, a_n
Suma:=0
For i=1 to n
If a_i>0 then Suma:=Suma+a_i
Salida: Suma

14. Suma de los elementos de una lista
entre dos posiciones fijadas
Entrada: a_1, …, a_n; m, m’ (1≤m≤m’≤n)
Suma:=0
For i=m to m’
Suma:=Suma+a_i
Salida: Suma

15. Producto de los números pares de
una lista
Entrada: a_1, …,a_n
Producto:=1
For i=1 to n
If a_i mod 2=0 then
Producto:=Producto*a_i
Salida: Producto

16. Determinar si en una lista hay un
múltiplo de 3
Entrada: a_1, …,a_n
S:=1 (switch)
i:=1
While S=1, i≤n
if a_i mod 3=0 then S:=0
i:=i+1
If S=0 then r:=“Sí” else r:=“No”
Salida: r

17. Determinar una lista con los
múltiplos de tres de una lista dada
Entrada: a_1, …,a_n
j:=0
For i=1 to n
if a_i mod 3 =0 then j:=j+1, b_j:=a_i
If j=0 then r:=“No hay múltiplos de tres” else
r:=b_i,…,b_j (ejercicio)
Salida: r

18. Valor absoluto
Entrada: a
If a>0 then |a|:=a else |a|=-a
Salida: |a|

19. Producto cartesiano
Entrada: a_1, …, a_n; b_1, …, b_m
k:=1 (el subíndice de la lista salida)
For i=1 to n
For j=1 to m
producto_k:=(a_i,b_j)
k:=k+1
Salida: producto_1, …, producto_(nxm)

20. Intercambiar dos variables
Es necesario introducir una variable auxiliar
Intercambiar(x,y)
z:=x
x:=y
y:=z
Esto está mal
x:=y
y:=x

21. Operaciones con listas
• Borrar
• Añadir
• Concatenar
• Sustituir
• Mezclar

22. Borrar(L,i)
Entrada: a_1, ..., a_n; i (1≤i ≤n)
For j:= i to n-1
a_j:=a_(j+1)
a_n:º=null
Salida: a_1, …, a_(n-1)

23. Añadir(L,m,i)
Entrada: a_1, ..., a_n; m; i (1≤i ≤n+1)
k:=n+1
While k>i
a_k:=a_(k-1)
k:=k-1
a_i:=m
Salida: a_1,…, a_(n+1)

24. Concatenar(L,L’)
Entrada: a_1, ..., a_n; b_1, …, b_m
For i=1 to m
L:=Añadir(L,b_i,n+i)
Salida: L

25. Sustituir(L,m,i)
Entrada: a_1, ..., a_n; m; i (1≤i ≤n)
a_i:=m
Salida:a_1, …, a_n

26. Herramientas
Asignaciones de listas L:=M
elementos(L)=1 si L tiene algún elemento y
0 en caso contrario.
Longitud(L)=n, esto es, el número de
elementos que tiene una lista.

27. Mezclar(L,L’)
Entrada: a_1, …, a_n; b_1, …, b_m (dos listas
ordenadas)
i:=0 (i es el subíndice de la salida)
While elementos(L)*elementos(L’)=1
if min(L_1,L’_1)=L_1 then j:=0 else j:=1
i:=i+1, M_i:=min(L_1,L’_1),
If j=0 then L:=Borrar(L,1) else L’:=Borrar(L’,1)
If Longitud(L)>0 then M:=concatenar (M,L) else
M:=concatenar(M,L’)
Salida: M

28. Algoritmos de Búsqueda
Problema: Dada una lista a_1, …, a_n y un
número a, determinar si a es un elemento
de la lista o no.
Ejemplo: 5,7,8,-2,-3; 8 (la salida será sí)
2,4,5,-3,-7; 10 (la salida será no)

29. Búsqueda secuencial
Entrada: a_1, …, a_n; a
s:=0, i:=1
while i≤n, s=0
If a_i=a then s:=1
i:=i+1
If s=0 then r:=“No” else r:=“Sí”
Salida: r

30. Búsqueda Binaria
Entrada: a_1≤…≤a_n; a
i:=1, j:=n, s:=0 (i y j representan los extremos inicial y final de
la lista)
While i<j,s=0
m:=(i+j)/2
If a_m=a then s:=1
else
if a_m<a then i:=m+1(cambia el extremo inicial)
else
j:=m-1 (cambia el extremo final)
If s:=1 then r:=“Sí”
else
If a_((i+j)/2)=a then r:=“Sí”
else
r:=“No”
Salida: r

31. Algoritmos de ordenación
Problema: Dada una lista a_1, …, a_n
ordenarla de menor a mayor (o al revés).
Ejemplo: 3,-2,4,-7;
-7,-2,3,4.

32. Algoritmo burbuja
Idea: Comparara cada elemento con el
siguiente, si están en el orden adecuado
se dejan así, si no se intercambian sus
valores.
Al finalizar una “vuelta” el último ha ocupado
su lugar.
Recomenzamos con una lista de longitud
una unidad menor, resultado de olvidar el
último.

33. Ordenación burbuja
Entrada: a_1, …, a_n
For j=1 to n-1 (j es la vuelta en la que estamos)
For i=1 to n-j (i es el contador de la lista)
if a_i >a_(i+1) then
x:=a_i
a_i:=a_(i+1)
a_(i+1):=x
Salida: a_1, …, a_n

34. Algoritmo selección
Usamos un algoritmo min que aplicado a una lista
saca m, i. Donde m es el mínimo de la lista e i
es el lugar que ocupa. (Ejercicio)
Idea: si el mínimo no está en el primer lugar,
intercambiamos el valor del primer lugar y el
mínimo. Recomenzamos con una lista de
longitud una unidad menor resultado de olvidar
el primer elemento de la lista.

35. Algoritmo selección
Entrada: L:=a_1, ..., a_n (asignación de listas)
T:=L
For j=1 to n-1
If min(T)_1 ≠a_j then
L:=Intercambiar(L,j,min(T)_2+j-1)
T:=Intercambiar(T,1, min(T)_2)
T:=Borrar (T,1)
Salida: L

36. Mínimo
Entrada: L:=a_1, ..., a_n
m_1:=a_1, m_2:=1
For i =2 to n
if a_i<m_1 then m_1:=a_i, m_2:=i
Salida: m_1, m_2

37. Borrar varios
Entrada: L:=a_1, ..., a_n; 1≤b_1 ≤… ≤b_m
≤n
i:=m
While i>0
L:=Borrar(L,b_i)
i:=i-1
Salida: L

38. Añadir varios
Entrada: L:=a_1, ..., a_n; 1≤b_1 ≤… ≤b_m
≤n; c_1,…,c_m
For i=1 to m
L:=Añadir(L,b_i,c_i)
Salida: L

39. Dividir con decimales
Entrada: a,b; n
a_0:=|a|/|b|
r_0:=|a| mod |b|
For i=1 to n
a_i=10*r_(i-1)/|b|
r_i:=10*r_(i-1) mod |b|
If a*b>0 then r:=a_0’a_1...a_n
else r:=-a_0’a_1…a_n
Salida: r

40. Lista de los positivos
Entrada: a_1, …, a_n
j:=0
For i=1 to n
if a_i>0 then
j:=j+1, b_j:=a_i
If j=0 then r:=”No hay positivos” else r:=b_1,
…,b_j
Salida: r

41. Lista de los mayores que m
Entrada: a_1, …, a_n; m
j:=0
For i=1 to n
if a_i>m then
j:=j+1, b_j:=a_i
If j=0 then r:=”No hay” else r:=b_1,…,b_j
Salida: r

42. Borrar los positivos
Entrada: a_1, …, a_n
j:=n
While j>0
if a_j>0 then L:=Borrar(L,j)
j:=j-1
If elementos(L)=0 then r:=“No queda nada”
else r:=L
Salida: r

43. Máximo del producto de dos
elementos distintos
Entrada: a_1, …, a_n
M:=a_1*a_2
For i=1 to n-1
For j=i+1 to n
if M<a_i*a_ j then M:=a_i*a_ j
Salida: M

44. Máximo del producto de dos
elementos distintos
Entrada: a_1, …, a_n
k:=0
For i=1 to n-1
For j=i+1 to n
k:=k+1,b_k:=a_i*a_ j
Salida: maximo(b_1,..,b_k)

45. Máximo de las diferencias de
dos elementos de una lista
Entrada: a_1, …, a_n
M:=a_1-a_2
For i=1 to n
For j=1 to n
If M<a_i-a_j, i ≠j then M:=a_i-aj
Salida: M

46. Real RAM (los datos son números
reales)
Alineados
Entrada: a_1,a_2; b_1,b_2; c_1,c_2;
If det(a_1-b_1,a_2-b_2,b_1-c_1,b_2-c_2)=0
then alineados:=1 else alineados:=0
Salida: alineados

47. Hay 3 puntos alineados
Entrada: a_1=a_11, a_12; …, a_n=a_n1,a_n2
s:=1, i:=1,
While s=1, i ≤ n-2,
j:=i+1
while s=1, j ≤n-1
k:=j+1
while k ≤ n, s=1
if alineados(a_i,a_ j, a_k)=1 then s:=0
k:=k+1
j:=j+1
i:=i+1
Salida: s

48. Complejidad
Objetivo: diseñar mecanismos para evaluar
la eficiencia de un algoritmo.
Parámetros que sería interesante controlar:
– Espacio (unidades de memoria)
– Tiempo (número de operaciones básicas)
– En promedio
– En el peor de los caso

49. Nuestra elección
Controlar el tiempo.
En el peor de los casos.
Definición: Sea un algoritmo A que
funciona sobre una entrada de tamaño n.
Se define la función T(n) como el número
de operaciones que realiza el algoritmo en
el peor de los casos.

50. Dos observaciones
1. No hace falta ser muy exacto
• T(n)=2n, T’(n)=2n+1, T’’(n)=2n^4
2. Tampoco es fácil ser exacto
Necesitamos un instrumento matemático
que mida el carácter asintótico.
No distinga T de T’ y sí de T’’

51. Relación de dominancia
Sean dos funciones T:N→R+ y S:N →R+ de
los naturales en los reales positivos.
Diremos que S domina a T y escribiremos
T Є O(S) si existe una constante k y un
número natural m de modo que
T(n)≤kS(n) para cada n≥ m

52. Orden de complejidad
En las condiciones de la transparencia
anterior diremos que T y S son del
mismo orden de complejidad si T
domina a S y S domina a T. Escribiremos
O(T(n))=O(S(n))

53. Complejidad de un algoritmo
La complejidad de un algoritmo se define
como el orden O(T(n)) de la función
número de operaciones en el peor de los
casos.
Ejemplo: Si T(n)=2n+1 entonces el
algoritmo es de complejidad lineal.