Capítulo 2

Algoritmos

Problema real

Planteamiento Formal

¿Presenta Solución?

ALGORITMO

Demostración de que funciona

Estudio de su eficiencia

Lógica

Otra vez lógica

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 ComputacionalRAM

• 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 x:=5y:=3

Sumas: x+y (=8)Restas: x-y (=2)Cociente: x/y (=1)Resto: x mod y (=2)Comparaciones: 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) (el posible contador no cambia)

Instrucciones

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_nS:=1 (switch)i:=1While S=1, i≤n

if a_i mod 3=0 then S:=0i:=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 auxiliarIntercambiar(x,y)

z:=xx:=yy:=z

Esto está malx:=yy:=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’)=1if min(L_1,L’_1)=L_1 then j:=0 else j:=1i:=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) elseM:=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 BinariaEntrada: a_1≤…≤a_n; ai:=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)/2If a_m=a then s:=1 elseif a_m<a then i:=m+1 (cambia el extremo inicial)elsej:=m-1 (cambia el extremo final)

If s:=1 then r:=“Sí” else

If a_((i+j)/2)=a then r:=“Sí”elser:=“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_nFor 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) thenx:=a_ia_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; na_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_nSalida: r

Lista de los positivos

Entrada: a_1, …, a_nj:=0For 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; mj:=0For 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_jSalida: r

Borrar los positivos

Entrada: a_1, …, a_nj:=nWhile 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_n2s:=1, i:=1, While s=1, i ≤ n-2,

j:=i+1while s=1, j ≤n-1

k:=j+1while k ≤ n, s=1

if alineados(a_i,a_ j, a_k)=1 then s:=0k:=k+1

j:=j+1i:=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.