Capítulo 2 Algoritmos

Lógica Complejidad Otra vez lógica

Definición de Algoritmo: Se define como un procedimiento constructivo para la resolución de un problema y consta de: Datos de entrada (precisamente definidos), una cantidad finita y ordenada de instrucciones que 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 x:=5 y:=3 Sumas: x+y (=8) Restas: x-y (=2) Cociente: x/y (=1) Resto: x mod y (=2) Comparaciones: x>y ≠ ≤ ≥ <

Instrucciones Condicionales: Bucles: 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)

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 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) j:=m-1 (cambia el extremo final) If s:=1 then r:=“Sí” If a_((i+j)/2)=a then r:=“Sí” 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 No hace falta ser muy exacto T(n)=2n, T’(n)=2n+1, T’’(n)=2n^4 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 O(T(n))=O(S(n)) 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.