Transcript Capítulo 2 Algoritmos Problema real Lógica Planteamiento Formal ¿Presenta Solución? ALGORITMO Otra vez lógica Demostración de que funciona Estudio de su eficiencia Complejidad.

Capítulo 2
Algoritmos
Problema
real
Lógica
Planteamiento
Formal
¿Presenta Solución?
ALGORITMO
Otra vez lógica
Demostración
de que funciona
Estudio de su
eficiencia
Complejidad
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.
Resaltamos
• Datos de entrada.
• Operaciones básicas.
• El algoritmo termina.
• Hay que demostrar que resuelve el
problema.
• Hay que estudiar su eficiencia.
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.
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)
Ejemplos
Asignaciones
Sumas:
Restas:
Cociente:
Resto:
Comparaciones:
x:=5
y:=3
x+y (=8)
x-y (=2)
x/y (=1)
x mod y (=2)
x>y
≠≤≥<
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)
Instrucciones
(el posible contador no
cambia)
Máximo de dos números
Entrada: a, b (dos números enteros)
If a>b then m:=a else m:=b
Salida: m
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
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
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
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
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
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
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
Valor absoluto
Entrada: a
If a>0 then |a|:=a else |a|=-a
Salida: |a|
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)
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
Operaciones con listas
•
•
•
•
•
Borrar
Añadir
Concatenar
Sustituir
Mezclar
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)
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)
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
Sustituir(L,m,i)
Entrada: a_1, ..., a_n; m; i (1≤i ≤n)
a_i:=m
Salida:a_1, …, a_n
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.
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
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)
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
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
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.
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.
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
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.
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
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
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
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
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
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
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
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
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
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)
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
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
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
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
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.
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’’
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
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))
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.