4 Recursividad. Contenido. 4. Recursividad Definición y Tipos de recursividad

Transcripción

1 4 Recursividad Programación Modular. ETSIT. 1 o C, Apuntes del profesor Juan Falgueras 2004 Contenido 4. Recursividad Definición y Tipos de recursividad La recursión es como la iteración Tipos de recursión Implementación interna en un ordenador Verificación de la corrección de un algoritmo recursivo Conveniencia del uso de la recursividad Ejemplos de programas recursivos La función de Fibonacci Dígitos binarios La búsqueda binaria Quicksort Torres de Hanoi Ackerman Búsqueda binaria Algoritmos de vuelta atrás Recursividad Hasta ahora hemos visto formas de estructurar tanto datos como programas, mediante funciones. Las funciones resuelven cometidos concretos y llevan parámetros que las hacen ser útiles para distintas situaciones. Las funciones que hemos visto hasta ahora se resolvían por sí mismas o, a lo sumo podían pedir ayuda otras funciones que terminaban resolviéndose sin más llamadas. Sin embargo, hay veces en que una función sólo se puede resolver volviéndose a llamar a sí mismas. Se trata de funciones recursivas. Cuándo tiene esto sentido? En este tema se introduce el concepto de recursión, se examinan los posibles casos, se muestra cómo un ordenador, que es fundamentalmente iterativo, no recursivo, puede emular la recursión; se dan reglas para comprobar que las solucines recursivas que se construyan tengan final y se presentan diversos ejemplos importantes de recursión Definición y Tipos de recursividad Se dice que un proceso es recursivo si se resulve llamándose a sí mismo. Para que la recursión tenga sentido (un final útil) cada vez que se llame internamente a sí misma deberá hacerlo de una manera menos recursiva hasta que finalmente se llame a sí misma de una manera no recursiva. La recursión infinita es inútil. Lo único que determina el comportamiento de una función son los parámetros que son los que dan idea del tamaño del problema. La función no es recursiva para algunos valores del parámetro que se denominan casos base. Toda función recursiva, pues, debe tener algún caso base y toda llamada recursiva dentro de ella debe tender hacia el caso base.

2 4.1 Definición y Tipos de recursividad La recursión es como la iteración En muchas ocasiones se puede ver que la recursión no es más que la repetición (iteración) de una serie de acciones. Esta iteración se da hasta llegar a un valor de una variable. Pero en la recursión esta iteración se está desarrollando mediante la llamada de la función a sí misma con un parámetro que es la variable que determina el final de la recursión, en vez de ser un bucle dentro de una función normal. Así pues, en la iteración, es la guarda del bucle la que determina cuándo acabará la repetición; en la recursión es el parámetro. Por ejemplo: { 1 x = 0 = x f(x 1) x > 0 es una definición formal de la función factorial en forma recursiva. que podría corresponder al algoritmo recursivo: 1 int f(int n) { 2 if (0==n) 3 return 1; 4 else 5 return n * f(n-1); 6 } pero también sabemos que la forma iterativa de factorial es: = x (x 1) (x 2)... 1 que está definida mediante una repetición de multiplicaciones empezando en el propio valor x y en las que el siguiente multiplicador disminuye hasta llegar al valor 1. El algoritmo sería: 1 int f(int x) { 2 int r, i; 4 for (i=x, r=1; i>1; --i) 5 r *= i; 6 return r; 7 } En este sentido la recursividad es una nueva forma de ver las acciones repetitivas permitiendo que un subprograma se llame a sí mismo para resolver una versión más pequeña del problema original. Sin embargo, no siempre la recursión es tan similar a la iteración Tipos de recursión Estructuralemente existen dos formas de recursión: 1. la directa: es la que hemos visto hasta ahora en la que la función se llama a sí misma. 2. Indirecta: es la recursión que se produce cuando la función se llama no a sí misma sino a otra función (y esta quizás a otra) que termina llamándo a la función inicial. Se produce así una cadena: f(a) g(b) h(c)... f(a ) Así la recursión directa es una forma más simple de recursión en la que no existen g(), h(), etc. Existen distintos modos de hacer la recursión: de cabeza la recursión de cabeza se produce cuando la llamada recursiva se hace justo al principio del procedimiento recursivo, antes que ninguna otra operación. Por ejemplo:

3 4.1 Definición y Tipos de recursividad 3 directa final x x''' x'' indirecta final x x? x' Figura 1: En la recursión directa, la función se llama a sí misma; en la indirecta llama a otras que terminan llamándola de nuevo a ella. 1 char ultimaletra(char *cadena) 2 { 3 if (*cadena!= \0 ) { 4 return ultimaletra(cadena+1); 5 } 6 } de cola por el contrario, en la de cola la llamada se hace al final después de todas las operaciones. intermedia implica la existencia de operaciones antes y después de la llamada recursiva. múltiple se producen varias llamadas, recursivas en distintos puntos del procedimiento. anidada la anidada o no primitiva es aquella en la que la recursión se produce en un parámetro de la propia llamada recursiva. Es decir, al hacer la llamada recursiva se utiliza un parámetro que es el resultado de una llamada recursiva. x' x' x' f(x') A B C A B C A B C A B C Figura 2: Dependiendo del momento del desarrollo del algoritmo en el que se produce la recursión se tienen cuatro formas, en general Implementación interna en un ordenador Consideremos ahora la ejecución de la función recursiva. En un lenguaje de programación, cuando se llama a un procedimiento (o función), lo que se hace es que se guarda la dirección de la sentencia llamante como dirección de retorno; se asigna nueva memoria para las variables locales del procedimiento, y al finalizar la ejecución del procedimiento, se libera la memoria asignada a las variables locales y se vuelve la ejecución al punto en que se hizo la llamada haciendo uso de la dirección de retorno, dirección de la instrucción que sigue a la instrucción de llamada al procedimiento. Por otro lado, tenemos que estudiar dos conceptos más. Uno es la pila (stack) y el otro son los registros de activación de los procedimientos. Una pila es una estructura de datos en la que sólo cabe añadir o quitar un dato cada vez, pero, tal y como se hace con una pila de libros, por ejemplo, para el dato a extraer sólo es accesible el último libro que se apiló. Debido a este comportamiento a las pilas también se las conoce como estructuras último que entra, primero que sale (LIFO).

4 4.2 Verificación de la corrección de un algoritmo recursivo 4 return addr (x) int i; Figura 3: La pila de recursión se va formando en cada llamada dejando encima los datos de la última llamada para ser los inmediatamente pendientes de resolver. El registro de activación de un procedimiento es un bloque de memoria que contiene información sobre las constantes, variables locales declaradas en el procedimiento y los parámetros que se le pasen en esa llamada al procedimiento, junto con la dirección de retorno que corresponde a esa llamada. Los lenguajes de programación actuales utilizan una pila especial que el sistema tiene para las llamadas a subrutinas. En esta pila el código máquina del programa cada vez que tiene que llamar a un procedimiento guarda su registro de activación. Si dentro de esta subrutina se llama de nuevo a sí misma en forma recurrente, dado que la creación del registro de activación del propio procedimiento se hace sobre una pila sin borrar los registros de activación anteriores, se puede generar uno nuevo para cada llamada recursiva. Al final nos encontramos con que con cada llamada recursiva se están apilando registros de activación sobre los registros de activación de las llamadas anteriores. Cuando una de las llamadas recursivas se resuelve por fin sin recursión, su registro de activación se quita de la pila (se desapila) siguiendo la ejecución del programa por dónde iba cuando se llamó esta última vez. Y por tanto siguiendo también con las variables y parámetros que se tenían en aquél momento. De nuevo, cuando esta llamada se resuelve sin recursión, se repite la disminución de la pila y vuelta al estado anterior. Debido a la sobrecarga (overhead) que producen las operaciones sobre la pila, la creación y borrado de los registros de activación, los procedimientos recursivos consumen más tiempo y memoria que los programas no recursivos. Sólo en determinadas ocasiones, debido a la estructura de datos usada en el problema o al planteamiento del mismo la recursión es preferible, y evitar la recursión es bastante más difícil que dar una solución recursiva al problema Verificación de la corrección de un algoritmo recursivo Para comprobar que un algoritmo recursivo funciona correctamente es necesario que siga las tres reglas siguientes: 1. Existe un caso base (por cada llamada recursiva que se haga dentro del algoritmo debe haber un valor) para el cual el algoritmo finalice sin recursión. Por ejemplo, fact(0) = 0 sin recursión. En el algoritmo factorial se produce una llamada recursiva con lo cual es suficiente con un caso base. 2. Todos los posibles argumentos de las llamadas recursivas se reenvían tendiendo sus valores hacia un caso base. En el caso del factorial, ya que la llamada recursiva que se hace es con fact(n-1) y n se suponía natural, tienden para valores de n > 0 al valor La función es correcta, para valores distintos del caso base. En el caso del factorial, por inducción, tendríamos que si fact(n) = n!, entonces fact(n + 1) = n fact(n) = (n + 1)!

5 4.3 Conveniencia del uso de la recursividad 5. En general la búsqueda de una solución recursiva de los algoritmos se facilita mediante la localización de los casos bases. Una vez respondidos a ellos, se trata de que el argumento en general tienda a estos valores Conveniencia del uso de la recursividad La recursión debería de evitarse siempre que se pueda por motivos de eficiencia, como se ha visto en el apartado Sin embargo, sería justificable emplearla cuando: 1. se sabe que la función no va a generar demasiada profundidad de llamadas recursivas; particularmante por que la pila del sistema donde se guardan todos las variables locales y parámetros, es relativamente pequeña y podría colapsar el sistema. 2. se sabe que la función no va a utilizar estructuras de datos locales demasiado grandes. Si así fuese el caso, aunque la solución se mantuviese como recursiva habría que recurrir a otra forma de mantener los datos. 3. cada llamada no genera a su vez llamadas ya resueltas en otras llamadas que se generarán o se han generado antes. Este problema hay que analizarlo antes y es frecuente en recursión. Es una fuente de ineficiencia usual en recursión el que una función se evalúe múltiples veces con el mismo valor de parámetro en las llamadas recursivas generadas internamente, 4. La solución no es planteable de forma sencilla de otra manera. Ocurre en muchos casos que la forma recursiva es muy más clara que la iterativa, como se verá en los ejemplos. En otras palabras, si la forma iterativa está ahí y es sencilla, es preferible Ejemplos de programas recursivos La función de Fibonacci fib(x) = { 1 x 2 fib(x 2) + fib(x 2) x > 2 La función de Fibonacci proviene del bucólico problema de la multiplicación de conejos. Supongamos que partimos de una pareja de conejos recién nacidos, y queremos calcular cuántas parejas de conejos forman la familia al cabo de n meses si: Los conejos nunca mueren. Un conejo puede reproducirse al comienzo del tercer mes de vida. Los conejos siempre nacen en parejas macho-hembra. Al comienzo de cada mes, cada pareja macho-hembra, sexualmente madura, se reproduce en exactamente un par de conejos machohembra. Para un n pequeño, por ejemplo 6, la solución se puede obtener fácilmente a mano: Mes 1: 1 pareja, la inicial Mes 2: 1 pareja, ya que todavía no es sexualmente madura. Mes 3: 2 parejas; la original y una pareja de hijos suyos. Mes 4: 3 parejas; la original, una pareja de hijos suyos nacidos ahora y la pareja de hijos suyos nacidos en el mes anterior. Mes 5: 5 parejas; la original, una pareja de hijos suyos nacidos ahora, las dos parejas nacidas en los meses 3 y 4, y una pareja de hijos de la pareja nacida en el mes 3.

6 4.4 Ejemplos de programas recursivos 6 Mes 6: 8 parejas; las 5 del mes anterior, una pareja de hijos de la original, una pareja de hijos de la nacida en el mes 3 y una pareja de hijos nacida en el mes 4. Si deseamos saber el número de parejas al cabo de n meses, para un n cualquiera, podemos construir un algoritmo recursivo fácilmente a partir de la siguiente relación: { 1 n 2 Parejas(n) = Parejas(n 1) + Parejas(n 2) n > 2 En esta relación Parejas(n 1) son las parejas vivas en el mes n 1, y Parejas(n 2) son las parejas que nacen en el mes n a partir de las que había en el mes n 2. La serie de números Parejas(1), Parejas(2), Parejas(3),... es conocida como la Serie de Fibonacci, la cual modela muchos fenómenos naturales. El crecimiento de esta función, como demuestra la su aproximación: y(k) 1/ 5( ) k, es exponencial. Los valores de y k coinciden (en su parte entera redondeada desde k = 1 con los de f(k)). 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1.597, 2.584, 4.181, 6.765, , , , , , , , , , , , son sólo los valores alcanzado hasta el término 30. En forma de algoritmo recursivo la función de Fibonacci sería: 1 int fib(int n) { 2 if (n<=2) 3 return 1; 4 else 5 return fib(n-1)+fib(n-2); 6 } es un ejemplo de sencillez y falta de eficiencia recursiva, como se vé en el árbol de recursión de la misma (Fig. 4). f(5) f(6) f(4) f(4) f(3) f(2) f(3) f(3) f(2) f(2) f(1) f(2) f(1) f(2) f(1) Figura 4: Árbol de recursión del algoritmo recursivo Fibonacci. Obsérverse la cantidad de llamadas repetidas que se producen sólo para calcular el sexto valor de la serie. Matemáticamente los números de la serie de Fibonacci aparecen en muchas ocasiones. Una expresión cerrada (no recurrente) para calcularlos es: ( fib(n) = 1 (1 + 5 ) n ( ) 1 5 ) n = φn φ n siendo φ = (1 + 5)/2 y φ = (1 5)/2 el número aúreo. Fibonacci crece exponencialmente ya que el término que resta es menor que 1 (φ ) mientras que φ El número de dígitos del n-simo término crece rápidamente, de manera lineal con n.

7 4.4 Ejemplos de programas recursivos 7 Programación dinámica del algoritmo recursivo de Fibonacci. El problema de la solución recursiva de Fibonacci es que llama multitud de veces a los mismos cálculos que acaba de resolver. Para valores pequeños esto no tiene importancia, pero el crecimiento exponencial de este número de llamadas repetidas lo hacen realmente ineficiente respecto a una sencilla solución iterativa mediante un simple bucle. La Programación Dinámica consiste almacenar los valores que se van obteniendo durante el proceso completo como resultados parciales reaprovechables para subsiguientes cálculos, optimizando así el análisis global. En nuestro caso, bastaría con almacenar, conforme los calculamos, los valores de los fibs anteriores, de manera que cuando se pidan de nuevo esos valores se devuelvan directamente del almacén de los calculados. En el lenguaje de programación C, por ejemplo, se puede mantener la información calculada en variables locales de una llamada a otra mediante variables locales estáticas. En este caso, nos interesa mantener un largo array de valores calculados pero también, dado que tan sólo la primera vez necesitará este array inicializarse, una variable que nos diga si es la primera vez o no que ejecutamos la función. Quedaría: 1 unsigned fib(int n) { 2 static unsigned fibs[1000]; 3 static bool primeravez=true; // sólo se inicializa una vez 4 if (primeravez) { 5 fibs[1]=fibs[2]=1; 6 for(int i=3; i<1000; i++) 7 fibs[i] = 0; 8 primeravez = false; 9 } 10 if (fibs[n]!= 0) 11 return fibs[n]; 12 fibs[n] = fib(n-1) + fib(n-2); 13 return fibs[n]; 14 } Dígitos binarios El siguiente algoritmo recursivo escribe secuencialmente (y de manera ordenada) los dígitos binarios del parámetro entero que recibe: 1 typedef unsigned long int base; 2 void dec2bin(base n) { 3 if (n >= 2){ 4 dec2bin(n / 2); 5 cout << n % 2; 6 } else { 7 cout << n; 8 } 9 } Su especificación formal sería: 0 x = 0 dec2bin(x) = 1 x = 1 dec2bin(x/2) x %2 x 2 indicando la concatenación de cadenas de letras. La operación % sería la operación resto que devuelve el resto de la división entre sus operandos La búsqueda binaria Z BusquedaBin(E T a[n], E T x) requiere que el array esté ordenado. Para responder recursivamente podemos lanzar una función recursiva en la que acotemos los límites binarios de la búsqueda; lanzaríamos la primera llamada con 0, N 1:

8 4.4 Ejemplos de programas recursivos 8 1 int buscarr(t ordenado[], int ini, int fin, T x) { 2 int mitad; 4 if (ini > fin) 5 return -1; 7 mitad = (fin + ini) / 2; 8 if (ordenado[mitad] == x) 9 return mitad; 10 else if (x > ordenado[mitad]) 11 return Buscar(ordenado, mitad+1, fin, x); 12 else 13 return Buscar(ordenado, ini, mitad-1, x); 14 } 16 int BusquedaBin(T ordenado[], T x) 17 { 18 return buscarr(ordenado, 0, N-1, x); 19 } Quicksort El algoritmo de ordenación de Hoare (apodado Quicksort) es mucho más sencillo en forma recursiva. Cómo funciona? Se trata de separar en dos partes el array, a un lado los elementos más pequeños y al otro los más grandes (o iguales) a un elemento de referencia llamado pivote, que se toma del mismo array (ver la Figura 5). En esta división o partición está el secreto de Quicksort. Para que la cosa funcione bien, se debería elegir el pivote de manera que quedara más o menos en medio del array repartido. Una vez hecha esta partición podemos plantearnos recursivamente el mismo problema de ordenación pero con dos arrays la mitad de largos. Esto llevaría en el primer array a otros dos arrays también separados por un nuevo pivote y así sucesivamente. Lo interesante es que cada subarray mitad está ya en su sitio ( rápidamente ) desde el principio y, por ende, el array concatenación de todos ellos. 1 Para que el array quede dividido por la mitad en cada partición es necesario elegir muy bien el pivote o referencia. Para conseguir que el pivote quede enmedio, debería tomarse la mediana de los elementos del array. De hecho algunas versiones de este algoritmo de ordenación buscan esta mediana primero entre los elementos del array, pero este proceso hay que descartarlo en general ya que lo que se gana en cuanto a la simetría y eficiencia de las particiones se pierde en la búsqueda de la mediana de los subarrays, necesariamente búsquedas de complejidades lineales. Así pues, el pivote se elige al azar entre los elementos del array recibido. Al no haber criterio a priori se toma o bien el primero o bien el último, o, si se es supersticioso, el de enmedio. Tomando como referencia el último: x = a[n 1] Una vez tomado el pivote x empezamos la partición. Para ello el siguiente paso es localizar (desde 0 hasta i) un punto hasta el cual todos los elementos del array sean menores que el pivote x elegido. Se para la búsqueda y se deja allí una referencia i, asímismo se busca otro punto bajando desde el final del array (desde N 1 hasta j) hasta el cual todos los elementos del array sean mayores o iguales al pivote, sería j. Tenemos pues dos puntos posiblemente separados i y j que contienen valores desordenados, uno mayor (o igual) (en i) y otro menor que el pivote (en j). Se intercambian esos valores y se repite este proceso subiendo el valor del índice i y bajando el del j con el mismo criterio (de nuevo una vez localizados los nuevos i y j se intercambian sus contenidos) hasta que i j. 1 Una vez lograda esta división el problema inicialmente de complejidad cuadrática N 2 queda dividido en la suma de dos problemas de la cuarta parte de complejidad (N/2) 2. El resultado final (N/2) 2 + (N/2) 2 1/2N 2 es de menor complejidad que si se trata siempre con todo el array de golpe, como se hace en los métodos de intercambio directo (burbuja, selección o inserción), que manejan todo el array en cada operación.

9 4.4 Ejemplos de programas recursivos 9 En el punto i = p en el que se encontró un elemento mayor (o igual) que el pivote x se tienen aseguradas las condiciones: k < p, a[k] < x y k > p, a[k] x Después de esto, dado que el elemento que queda en p puede ser mayor que el pivote x que está situado en a[n 1], se intercambia por él, dejando el pivote en p y garantizando un array con dos partes a[0..p] < r y a[p + 1..N 1] r. Se tienen pues ahora problemas como el inicial pero < Figura 5: Tras cada iteración se han intercambiado los elementos de manera que quedan los menores a un lado y las mayores al otro del valor elegido de referencia. recursivamente más pequeños. Con lo cual se abordan llamadas recursivas a cada parte del array para ordenarlos igualmente. Mientras más iguales sean los tamaños de las partes menos llamadas recursivas surgirán. En este sentido se puede dar un caso degenerativo de este algoritmo que sería el de tener como tamaño de una de las partes un elemento cada vez (en la otra los restantes) y por lo tanto se produciéndose N 1 llamadas recursivas que sólo sacan cada vez un elemento fuera del array a ordenar. El caso es que precisamente esta situación degenerativa se da con cierta facilidad. Basta con que nos den un array ordenado o invertido para que ocurra este desastre. Lo mejor para que no ocurra es que los elementos estén aleatoriamente repartidos. Se han hecho infinidad de estudios y mejoras de este algoritmo (particularmente interesantes las iniciadas por Sedgewick), para tratar de paliar sus debilidades. Nótese que las grandes cualidades de este algoritmo son las de hacer pocos intercambios y además haciendo viajar a los elementos grandes distancias cada vez que se hacen, lo que constituye las dos grandes cualidades más buscadas de los algoritmos de ordenación. Un detalle más a su favor, mucho más a nivel técnico es que los bucles de recorrido que hacen el trabajo duro son especialmente fáciles de optimizar en cualquier procesador ya que involucran sólo dos punteros a bloques que se van incrementando/decrementando en el propio procesador. 1 int particion(char a[], int iz, int de) 2 { 3 char x, t; 4 int i, j; 6 x = a[de]; // pivote 7 i = iz - 1; 8 j = de; 9 do { 10 do ++i; while (a[i] < x); // x hace también de centinela 11 do --j; while (j >= 0 && a[j] >= x); 12 if (i<j) intercambia(a[i], a[j]); 13 } while (i < j); 14 intercambia(a[i], a[de]); // asegura x en su sitio 15 return i; 16 } 18 void quick(char a[], int iz, int de) 19 { 20 int p; 22 if (de > iz) {

10 4.4 Ejemplos de programas recursivos p = particion(a, iz, de); 24 quick(a, iz, p-1); 25 quick(a, p+1, de); 26 } 27 } 29 void QuickSort(char a[]) 30 { 31 quick(a, 0, strlen(a)-1); 32 } murcielago m(u)rciela(g)o -i-> m(g)rciela(u)o mg(r)ciel(a)uo -i-> mg(a)ciel(r)uo mgaciel(r)u(o) -p-> mgaciel(o)u(r) = [mgaciel]o[ur] (m)gaci(e)l our -i-> (e)gaci(m)l our egaci(m)(l) our -p-> egaci(l)(m) our = [egaci]l[m our] egac(i)(i) lm our -p-> egac(i)(i) lm our = [egac]i[lm our] (e)g(a)c ilm our -i-> (a)g(e)c ilm our a(g)e(c) ilm our -p-> a(c)e(g) ilm our = [a]c[eg ilm our] ace(g)(g) ilm our -p-> ace(g)(g) ilm our = [a c e]g[ilm our] a ceg ilm o(u)(r) -p-> acegilmo(r)(u) = [acegilmo]r[u] acegilmoru Cuadro 1: Ejemplo de pasos intermedios en la ordenación in situ de un array. Las -i-> son reordenaciones para repartir entre los dos subarrays. Las -p-> la reubicación del pivote.

11 4.4 Ejemplos de programas recursivos Torres de Hanoi Las Torres de Hanoi es un juego cuya solución se simplifica mucho si se piensa como un problema recursivo. Se tienen 3 palos de madera, que llamaremos palo izquierdo, central y derecho. El palo izquierdo tiene ensartados un montón de discos concéntricos de tamaño decreciente, de manera que el disco mayor está abajo y el menor arriba. El problema consiste en mover los discos del palo izquierdo al derecho respetando las siguientes reglas: Sólo se pueden mover los discos de un palo a otro. Sólo se puede mover un disco cada vez. No se puede poner un disco encima de otro más pequeño. Se quiere diseñar un programa que recibiendo un valor entero N y escriba la secuencia de pasos necesarios para resolver el problema de las torres de Hanoi para N discos. Solución Para ver el problema de forma recursiva tenemos que pensar que la solución para N = 1 es trivial, mientras que para un valor más alto de N se puede reducir en cada ocasión en un valor N 1, descomponiendo la solución en 3 fases: 1. Mover los N 1 discos superiores del palo izquierdo al palo central, utilizando el palo derecho como palo auxiliar. 2. Mover el disco que queda del palo izquierdo al derecho. 3. Mover los N 1 discos del palo central al palo derecho, utilizando el palo izquierdo como auxiliar. Si N = 1, el problema se resuelve inmediatamente sin más que mover el disco del palo izquierdo al derecho. Para representar estos pasos en el ordenador, planteamos un procedimiento recursivo que recibe cuatro parámetros: El número de discos a mover. El nombre del palo a tomar como origen desde donde moverlos. El nombre del palo a tomar como destino hacia el que moverlos. El nombre del palo a usar como auxiliar. 1 Algoritmo Mueve(N, origen, auxiliar, destino) 2 Inicio 3 SI N == 1 ENTONCES 4 Mueve un disco del palo origen al destino 5 EN OTRO CASO 6 Mueve(N-1, origen, destino, auxiliar) 7 Escribe("Mueve un disco del palo ", origen, " al ", destino) 8 Mueve(N-1, auxiliar, origen, destino) 9 FINSI 10 Fin

12 4.5 Algoritmos de vuelta atrás 12 origen auxiliar destino origen auxiliar destino Figura 6: Mover n discos se reduce a mover n 1 al palo libre, mover después el que queda al destino, y volver a plantear recursivamente el mover, pero ahora, n 1 discos Ackerman La función Ackerman se define: n + 1, m = 0 A(m, n) = A(m 1, 1), n = 0 A(m 1, A(m, n 1)), m, n > 0 función recursiva no primitiva (anidada) (en la que como argumento aparece una recursión). Probarla para A(1, 1), A(2, 1) Qué ocurre para valores de m 5? No tiene especial interés matemático sino que apareció como banco de pruebas de la capacidad de recursión para los ordenadores. De hecho para valores muy pequeños de n y m se producen profundos niveles de anidamiento recursivo imposibles para los ordenadores usuales Búsqueda binaria Si se busca binariamente un valor dentro de un array ordenado, podemos descartar la mitad en la que seguro que no está el valor y llamar recursivamente a la misma función con el subarray en la parte en la que puede estar. Se deja como ejercicio Algoritmos de vuelta atrás De entre los métodos de resolución algorítmica de problemas el método de vuelta atrás o de backtracking se caracteriza por plantear el mismo problema pero con la muestra de menor tamaño, por lo tanto, en forma recursiva. Muchos problemas de juegos de tablero se resuelven mediante backtracking. Por ejemplo, si se necesita conocer si un camino en un laberinto es solución, se trata de recorrer hasta el final, y si no se puede llegar, se vuelve a plantear el recorrido en una de las 7 tres direcciones restantes en el momento de partida. Se deja como ejercicio resolver el problema del salto del caballo recursivamente mediante la técnica de bactracking (Figura 7).

13 4.5 Algoritmos de vuelta atrás 13 Figura 7: Posibles movimientos de salto que puede realizar un caballo (no importaría que las celdas del camino estuviesen o no ya ocupadas). Se trataría de pasar por todas las N N casillas de un tablero. Juan Falgueras Dpto. Lenguajes y Ciencias de la Computación Universidad de Málaga Despacho