7 INTRODUCCIÓN A LA RECURSIVIDAD.

Transcripción

1 7 INTRODUCCIÓN A LA RECURSIVIDAD. Contenido Concepto de recursión Ejemplos de programas recursivos Búsqueda y ordenación usando recursión Búsqueda Ordenación. Ejercicios CONCEPTO DE RECURSION Se dice que un proceso es recursivo si se puede definir en términos de si mismo, y a dicha definición se le denomina definición recursiva. 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. La función factorial es una función que se puede definir recursivamente y cuyo dominio es el de los enteros positivos. La función factorial, que se representa con el símbolo de exclamación, se define como: n! = n X (n - 1) X (n - 2) X... X 1 lo cual significa que n! es igual al producto de todos los enteros no negativos entre n y 1, inclusivos. Consideremos los factoriales de los enteros no negativos del 1 al 5: 1! = 1 2! = 2 X 1 3! = 3 X 2 X 1 4! = 4 X 3 X 2 X 1 5! = 5 X 4 X 3 X 2 X 1 Introducción a la Recursión. Pág 1

2 Si nos fijamos atentamente en las operaciones anteriores, podremos extraer una propiedad bastante interesante de la función factorial. Empecemos con el 5!, que es igual a: 5! = 5 X (4 X 3 X 2 X 1) pero lo que hay dentro del paréntesis es 4!, es decir (5-1)!, lo cual significa que : 5! = 5 X 4! Similarmente, podemos ver que: 4! = 4 X 3! y que 3! = 3 X 2!, y así sucesivamente. Si definimos 0! = 1 entonces n! se puede definir como: 1 si n = 0 n! = n x ( n 1)! si n > 0 Esta es la definición recursiva de la función factorial, ya que se define en términos de si misma. La primera regla de la definición, o caso base, establece la condición de terminación. Las definiciones recursivas nos permiten definir un conjunto infinito de objetos mediante una sentencia finita. La función factorial recursiva, se puede escribir como: /************************************************** * Autor: * Fecha: Versión: ***************************************************/ #include <iostream.h> #include <stdlib.h> int factorial(int param) if (param == 0) return 1 ; return param * factorial(param-1) ; int main() int N; cout << "Introduzca numero:"; cin >> N << endl; Introducción a la Recursión. Pág 2

3 cout << factorial(n)<< endl; system("pause"); return 0; Como puedes ver, la función Factorial se llama a si misma para hallar el valor de (N-1)!. A este tipo de recursión, donde un procedimiento se llama a sí mismo, se le denomina recursión explícita o recursión directa. Si un procedimiento P llama a otro Q, Q llama a R, R llama a S,..., y Z llama de nuevo a P, entonces también tenemos recursión, y a este tipo de recursión se le denomina recursión implícita o recursión indirecta. Consideremos ahora la ejecución de la función recursiva Factorial. En C++, cuando se llama a un procedimiento (o función), se guarda la dirección de la sentencia llamante como dirección de retorno, se asigna memoria a las variables locales del procedimiento, y al finalizar la ejecución del procedimiento, se libera la memoria asignada a las variables locales y se devuelve la ejecución al punto en que se hizo la llamada haciendo uso de la dirección de retorno. Pero qué es la dirección de retorno?. Cuando una sentencia escrita en un lenguaje de alto nivel se traduce a código máquina, dicha sentencia suele representar varias líneas de código máquina, es decir, la traducción no es una a una sino una a muchas. Cuando nos referimos a la dirección de retorno, nos estamos refiriendo a la dirección de la instrucción que sigue a la instrucción de llamada al procedimiento. Esta dirección podría estar en medio de la traducción de una sentencia de alto nivel (como en el caso de las llamadas a funciones) o podría ser la primera instrucción de la traducción de la sentencia de alto nivel, así como la propia llamada a la función. Podemos extraer entonces las siguientes conclusiones: 1. Para poder resolver un problema de forma recursiva se debe poder definir en términos de una versión más pequeña del mismo problema. 2. En cada llamada recursiva debe disminuir el tamaño del problema. 3. El diseño de la solución del problema ha de ser tal que asegure la ejecución del caso base y por tanto, el fin del proceso recursivo. 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 forma especial de organizar la memoria en la que la información siempre se añade en la cima y la información que se necesita, también se coge de la cima de la pila, al igual que una pila de hojas de papel. Debido a este comportamiento a las pilas también se las conoce como estructuras ultimo-en-entrarprimero-en-salir (Last-In-First-Out=(LIFO)). El registro de activación de un procedimiento es un bloque de memoria que contiene información sobre las constantes y variables declaradas en el procedimiento, junto con una dirección de retorno. Ahora estamos en disposición de trazar la ejecución del programa para el caso de N = 3. Para llevar a cabo la recursión, las computadoras usan pilas. Al comienzo de la ejecución de un procedimiento, la pila está vacía (Figura 1.a). Cuando la ejecución alcanza la sentencia: cout << factorial(n); se produce una llamada a la función Factorial con N = 3. Esto hace que se cree un registro de activación, y este registro se inserta en la pila (Figura 1b). Cuando se ejecuta la parte ELSE de la función Factorial (cuando la sentencia IF no es TRUE), se produce una nueva llamada a Factorial, pero esta vez el argumento es 3-1 =2. Introducción a la Recursión. Pág 3

4 RF RF RF N = 1 RF A N = 3 B N = 2 A N = 3 B N = 2 A N = 3 B (a) RF (b) (c) (d) N = 0 A N = 1 A N = 1 A RF 1 RF 1 RF 2 N = 2 N = 2 N = 2 A A A N = 3 N = 3 N = 3 N = 3 B B B B (e) RF (f) RF (g) (h) 6 6 (i) (j) Figura 1. Fases de la evolución de la pila durante la ejecución del programa Esta invocación se insertará en la cima de la pila (Figura 1.c). Esta vez, la dirección de retorno es la A. Debido a esta nueva invocación se tiene que volver a ejecutar el programa Factorial. La condición de la sentencia if aún es FALSE, y por tanto se volverá a invocar a la parte ELSE, pero esta vez con 2-1 =1 como argumento. Se inserta en la cima de la pila el registro de activación de esta nueva invocación (Figura 1.d). Una vez más se tiene que volver a ejecutar el procedimiento Factorial, en este caso el if también es FALSE y al ejecutarse la parte se volverá a llamar a Factorial pero esta vez con argumento 1-1=0 (Figura 1.e). En esta invocación la condición del if se evalúa a TRUE y se devuelve un 1. Lo primero que se hace es almacenar este valor en el registro de la función (RF), y usando la dirección de retorno del registro de activación podremos volver a la sentencia que hizo la llamada. En este instante, como se ha completado la ejecución del procedimiento Factorial(cuando N = 0), el computador no necesitará este último registro de activación, así que se puede eliminar (Figura 1.f). La sentencia a la que retornamos necesita el valor de la función Factorial(cuando N = 0), que se puede obtener del registro de la función (RF). Este valor se multiplicará por el valor de N que es 1. El resultado se copiará en el registro de la función y así concluirá la ejecución de Factorial(cuando N = 1), además su registro de activación será borrado (Figura 1.g). Los pasos anteriores se volverán a repetir dando lugar a un valor de 2 en el registro de la función y a un solo registro de activación en la pila (Figura 1.h). Esta vez, el valor obtenido del registro de la Introducción a la Recursión. Pág 4

5 función, que es 2, será multiplicado por N, cuyo valor actual es 3; el resultado, 6, se copiará en el registro de la función, y se usará la dirección B, con lo que retornaremos a la localización de la llamada original. Al final, la pila estará de nuevo vacía (Figura 1.j). 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. Pero, algunas veces, debido a la estructura de datos usada en el problema o al planteamiento del mismo, surge de forma natural, y evitar la recursión es bastante más difícil que dar una solución recursiva al problema EJEMPLOS DE PROGRAMAS RECURSIVOS La recursión, si se usa con cuidado, nos permitirá solucionar de forma elegante algunos problemas. En este apartado se van a resolver varios problemas usando procedimientos recursivos. En cada caso, sugerimos que antes de que veas el algoritmo no iterativo, lo intentes codificar tu mismo. Empezaremos con un problema simple. El término n-ésimo de la sucesión de Fibonacci se puede definir como: 1 si N = 1 ó N = 2 F( N ) = F( N 1) + F( N 2) si N > 2 Puedes observar que en esta definición,al igual que en la definición de la función factorial, tenemos un caso base que nos permite conocer el valor de la función. Esta regla es la condición de terminación. La otra regla es la relación de recurrencia. El ejemplo 1 ilustra un programa que lee varios valores de N y calcula el número correspondiente de la sucesión de Fibonacci. Ejemplo1. Programa que computa el N-ésimo término de la sucesión de Fibonacci haciendo uso de una función recursiva. /************************************************** * Autor: * Fecha: Versión: ***************************************************/ #include <iostream.h> #include <stdlib.h> double Fib(double N) if (N<= 2) return 1; return Fib(N-1) + Fib(N - 2); Introducción a la Recursión. Pág 5

6 int main() double i, N; cout << "Teclea un entero positivo: "; cin>> N << endl; for (i=1; i<=n; i++) cout << i<< " ésimo término de Fibonacci es: "; cout << Fib(i)<< endl; system("pause"); return 0; Analicemos ahora la ejecución de este programa; cuando N = 6 vamos a hallar el número de veces que se invoca la función Fib. Para hallar Fib(6), previamente tenemos que hallar Fib(5) y Fib(4); para hallar Fib(4), tenemos que hallar Fib(3) y Fib(2); y así sucesivamente. Las invocaciones de la función Fib se pueden ilustrar de la siguiente forma: Fib(6) Fib(5) Fib(4) Fib(4) Fib(3) Fib(3) Fib(2) Fib(3) Fib(2) Fib(1) Fib(2) Fib(1) Fib(2) Fib(1) Como se puede observar en el diagrama anterior, para hallar F(6) tenemos que llamar a la función Fib 15 veces. De esas 15 llamadas, tres tienen como argumento el 1, cinco tienen como argumento el 2, tres tienen como argumento el 3, dos tienen el 4 como argumento y con argumentos 5 y 6 sólo hay dos llamadas. Esto significa que el primer número de la serie de Fibonacci, se calcula tres veces, el segundo se calcula 5 veces, etc. Este análisis demuestra el por qué una función recursiva puede llegar a ser una herramienta muy costosa para solucionar un problema. El Ejemplo 2 muestra la versión iterativa, la cual es mucho más eficiente y fácil de escribir. Introducción a la Recursión. Pág 6

7 Ejemplo2. Programa que computa el N-ésimo término de la sucesión de Fibonacci sin usar recursión. /************************************************** * Autor: * Fecha: Versión: ***************************************************/ #include <iostream.h> #include <stdlib.h> double Fib(double N) double i, Primero, Segundo, Siguiente; Primero = 1; Segundo = 1; Siguiente = 1; for (i=3; i<=n ; i++) Siguiente = Primero + Segundo; Primero = Segundo; Segundo = Siguiente; return Siguiente; int main() double i,n; cout << "Teclea un entero positivo: " ; cin >> N; for (i=1; i<=n; i++) cout << i << " i-esimo termino de Fibonacci es: "; cout << Fib(i); cout << endl; system("pause"); return 0; Aunque el programa del ejemplo anterior es más eficiente, en este programa es más difícil ver la relación entre las sentencias de la función Fib y la definición de la función Fibonacci. Una forma de hacer que el procedimiento recursivo sea más eficiente es la de usar algún tipo de memoria que nos permita recordar los cálculos que ya hemos realizado y que por tanto no tengamos que repetirlos. Dicha memoria podría ser un array que inicialicemos a cero ya que todos los números que componen la sucesión de Fibonacci son mayores que cero. Podemos usar un array de tamaño 10. Asumimos que el i-ésimo elemento de este array se corresponde con el i- ésimo término de la sucesión de Fibonacci. Al principio, conocemos los dos primeros términos de la sucesión de Fibonacci. Durante el cálculo del N-ésimo término de la sucesión de Fibonacci, si N es menor o igual que 10, comprobaremos el N-ésimo elemento de dicho array. Si dicho elemento es mayor que cero, simplemente devolveremos ese valor; en otro caso tendremos que calcular el N-ésimo término de la sucesión de Fibonacci, almacenarlo en la posición correspondiente del array y devolverlo al programa principal. Si N es mayor que 10, tendremos que calcular su valor, pero eventualmente dicha computación hará uso de los valores ya precalculados y almacenados en el array. El Ejemplo 3 usa esta técnica para calcular el N-ésimo término de Fibonacci. Esta aproximación Introducción a la Recursión. Pág 7

8 reduce el número de llamadas al procedimiento; por tanto su ejecución ahorra tiempo a expensas de hacer uso de más espacio de memoria. Ejemplo3. Programa que computa el N-ésimo término de la sucesión de Fibonacci usando un algoritmo recursivo con memoria. /************************************************** * Autor: * Fecha: Versión: ***************************************************/ #include <iostream.h> #include <stdlib.h> const int Tamanyo = 10; typedef int TipoMemoria[Tamanyo]; TipoMemoria Memoria; void DefinirMemoria( TipoMemoria &M) int i; M[1] = 1; M[2] = 1; for (i=3; i<=tamanyo; i++) M[i] = 0; int Fib(int N) int K ; if (N < Tamanyo) if (Memoria[N]!= 0) return Memoria[N]; K = Fib(N-1) + Fib(N-2); Memoria[N] = K; return K; return (Fib(N-1) + Fib(N-2)); int main() int N; DefinirMemoria(Memoria); Cout << " Termino Fibonacci?: "; Cin >> N ; Cout << endl; if (N > 0) cout << N; cout << " ésimo término de Fibonacci es: "; cout << Fib(N); cout<<"error en la entrada. "; Introducción a la Recursión. Pág 8

9 cout << " N debería ser mayor que cero."; system("pause"); return 0; Ahora resolveremos un problema donde la recursión simplifica nuestro programa. El programa consiste en encontrar el equivalente binario de los números decimales. Como su nombre indica, los números decimales se escriben usando diez dígitos (0 al 9) y los números binarios se escriben usando dos dígitos (0,1). La representación binaria de un número decimal se puede hallar fácilmente considerando el siguiente algoritmo: Sea N un número positivo decimal. Hallar N % 2 y N / 2, y almacenamos el primero. Reemplazamos N por N/2. Repetimos el proceso hasta que N sea igual a cero. Ahora, si reescribes los valores almacenados en sentido contrario a como los obtuviste, obtendrás el equivalente binario de N. Por ejemplo: supongamos que N es 23. N N % 2 N / La representación binaria de 23 es Para resolver este problema sin usar recursión, necesitaremos un array para almacenar los dígitos binarios que vamos calculando, para después poder escribirlos al revés. El problema a la hora de usar arrays es que no conocemos el número de elementos que vamos a usar del array. Veamos, ahora, como nos puede ayudar la recursión. El equivalente binario de 11, que es igual a 23 / 2, es 1011 Así que, si podemos imprimir el equivalente binario de 11, será fácil escribir el equivalente binario del 23; lo único que tenemos que hacer es imprimir 23 % 2. Ahora observemos lo siguiente. El equivalente binario de 5, que es igual a 11 / 2, es 101. Si añadimos 11 % 2 = 1, nos da el equivalente binario del 11. Por tanto, si consideramos la representación binaria de un número como una cadena de dígitos binarios, podemos llegar a la siguiente definición: 0 sin = 0 Representación Binaria de N = 1 sin = 1 Representaciónbinariade( N / 2) ( N%2) donde representa la concatenación. Esta aproximación no requiere arrays y puede ser programada fácilmente. El programa se ilustra en el ejemplo 4. Introducción a la Recursión. Pág 9

10 Ejemplo4. Programa para hallar el equivalente binario de los números decimales. /************************************************** * Autor: * Fecha: Versión: ***************************************************/ #include <iostream.h> #include <stdlib.h> const int Base = 2; int N; void PrintBinario(int N) if (N > 0) PrintBinario(N/Base); // Imprime equivalente binario de N/2 Cout << N % Base; int main() cout << "Introduzca un entero positivo: "; cin >> N ; cout << endl; cout << " El Número Decimal "<< N <<" es igual a "; PrintBinario(N); Cout << " en binario " << endl; system("pause"); return 0; Un ejemplo simple de la ejecución de este programa sería: Entra un entero positivo: 256 El Número Decimal 26 es igual a en binario. Entra un entero positivo: El Número Decimal es igual a en binario. Entra un entero positivo: 23 El Número Decimal 23 es igual a en binario. Entra un entero positivo: El programa del Ejemplo 4 se puede modificar para hallar la representación de un número decimal en cualquier base B. Debemos notar que, si la nueva base B es mayor que 10, necesitaremos más símbolos además de los dígitos del 1 al 9. Tradicionalmente, se han usado los caracteres A, B, C, D,..., y así sucesivamente para representar el 10,11, 12, 13,.... Por ejemplo, el número 30 en decimal es equivalente en hexadecimal (B=16) a 1E, donde E representa el 14. Para manipular estos caracteres en este programa modificado, introducimos un array de caracteres llamado Dígitos. En este nuevo programa, en vez de imprimir el valor de N % Base Introducción a la Recursión. Pág 10

11 usaremos el valor obtenido, para indexar el array Digitos e imprimir el carácter almacenado en dicho elemento (Ejemplo 5). Ejemplo5. Programa para convertir números decimales a cualquier base hasta la base 16 /************************************************** * Autor: * Fecha: Versión: ***************************************************/ #include <iostream.h> #include <stdlib.h> const int BaseMax = 16; //Límite superior de la base typedef char TDigitos[BaseMax]; int N, NuevaBase; TDigitos Digitos; void DefinirDigitos(TDigitos &Digitos) char C; int i; C = '0'; for (i=0; i<=9; i++) Digitos[i] = C; C++; C = 'A'; for (i=10; i<=basemax-1; i++) Digitos[i] = C; C++; void PrintNuevaBase(int N,int NuevaBase) if (N > 0) PrintNuevaBase(N / NuevaBase, NuevaBase); cout<<digitos[n % NuevaBase]; int main() DefinirDigitos(Digitos); Cout << "Introduzca un entero positivo: "; Cin >> N; Cout << endl; Cout << "Entra la nueva base (2-16): "; Cin >> NuevaBase; Cout << endl; Cout << " El Número Decimal "<<N<<" es igual a "; PrintNuevaBase(N, NuevaBase); Cout << " en base "<<NuevaBase<<endl; system("pause"); return 0; Un ejemplo simple de la ejecución de este programa sería: Introducción a la Recursión. Pág 11

12 Entra un entero positivo: 123 Entra la nueva base (2-16): 16 El Número Decimal 123 es igual a 7B en base 16. Entra un entero positivo: Entra la nueva base (2-16): 8 El Número Decimal es igual a en base 8. Entra un entero positivo: Entra la nueva base (2-16): 10 El Número Decimal es igual a en base 8. Entra un entero positivo: Entra la nueva base (2-16): 12 El Número Decimal es igual a 16AB0 en base BUSQUEDA Y ORDENACION USANDO RECURSION Búsqueda Asumimos que tenemos un array llamado Ordenado de N elementos y que está ordenado en orden creciente. Consideremos el problema de determinar si un elemento dado, Item, está presente en dicho array. Si Item está presente en la lista, nos gustaría determinar su localización (Loc). Si Item no está presente en la lista, deberemos poner Loc a cero. Este problema se puede simplificar si reducimos el tamaño del array. Una forma de hacer esto es dividir el array en dos partes cogiendo el elemento X-ésimo del array, donde X es un índice seleccionado al azar entre 1 y N. Se nos presentan así tres posibilidades:. 1. Ordenado[X] = Item : En este caso, ya hemos encontrado el Item en el array, y ponemos Loc a X. 2. Ordenado[X] > Item : No podemos decir si el Item está o no en el array, pero ya que los elementos del array están en orden creciente, podemos ignorar la segunda parte del array;la siguiente vez, consideraremos sólo los elementos desde el primero al X Ordenado[X] < Item : No podemos decir si el Item está o no en el array, pero ya que los elementos del array están en orden creciente, podemos ignorar la primera parte del array; la siguiente vez, consideraremos sólo los elementos desde el X+1 al N. En los casos 2 y 3, el tamaño del array se reduce, y el mismo proceso, seleccionar un índice aleatorio X entre los valores del índice válidos (entre 1 y X-1 si se usa la primera parte; entre X +1 y N se usa la segunda parte) y comparar ese elemento con Item, se puede repetir sobre una porción más pequeña del array Ordenado. Eventualmente el tamaño del array bajo consideración será cero si el Item no está en el array; en otro caso se habrá localizado previamente. En vez de usar un índice X aleatorio, se suele coger la mitad del array. A este método se le denomina búsqueda binaria porque el elemento intermedio de un array divide al array en dos partes iguales o casi iguales (Si N es par). El programa principal del Ejemplo 6 tiene un programa principal que primero lee el número de elementos que va a contener el array Ordenado y que después lee los elementos. Dentro del bucle WHILE que sigue a la parte de entrada, el programa lee el Item a localizar y después invoca al procedimiento Buscar, que requiere cinco parámetros. Estos parámetros son, en orden: 2.Array Ordenado. Introducción a la Recursión. Pág 12

13 3.Primero: Cota inferior de la parte del array Ordenado en el que estamos interesados. 4.Ultimo: Cota superior de la parte del array Ordenado en el que estamos interesados. 5.Item: El valor que estamos buscando. 6.Loc: Si se encuentra el Item, Loc contendrá un índice a la posición dentro del array donde está el Item, sino contendrá cero. El procedimiento Buscar, después de comparar con el elemento mitad de la porción actual del array que estamos tratando, decide qué parte de la porción actual hay que ignorar. Si el elemento intermedio es menor que el Item, se ignora la primera parte, y se llama otra vez a Buscar con las cotas inferiores y superiores configuradas con los valores Mitad+1 y Ultimo. En otro caso, se llaman con las cotas Primero y Mitad-1 como cotas inferior y superior. Ejemplo6. Búsqueda Binaria recursiva /************************************************** * Autor: * Fecha: Versión: ***************************************************/ #include <iostream.h> #include <stdlib.h> const int Tamanyo = 100; // Tamaño del array typedef int Lista[Tamanyo]; Lista Ordenado; int N, i, Loc,Item; void Buscar(Lista Ordenado, int Primero, int Ultimo, int Item, int &Loc) int Mitad; if (Primero > Ultimo) Loc = 0; Mitad = (Ultimo + Primero) / 2; if (Ordenado[Mitad] == Item) Loc = Mitad; if (Ordenado[Mitad] < Item) Buscar(Ordenado, Mitad+1, Ultimo, Item, Loc); Buscar(Ordenado, Primero, Mitad-1, Item, Loc); int main() // Lectura del array Ordenado cout << "Número de elementos en Ordenado: "; cin >> N; cout << endl; if (N > Tamanyo) N = Tamanyo; // No se pueden leer más de Tamanyo elementos Introducción a la Recursión. Pág 13

14 cout<< "Introduzca los elementos: "; for ( i = 0; i<=(n-1);i++) cin >> Ordenado[i] ; cout << endl; cout << "Item a Buscar: "; cin >> Item ; Buscar(Ordenado, 0, N-1, Item, Loc); cout << Item ; if (Loc == 0) cout << " no está en la lista."; cout << " es igual al "; cout << Loc; cout << "-esimo elemento de la lista."; cout << endl; system("pause"); return 0; Ordenación La ordenación está muy relacionada con la mezcla. Mezclar es un término usado por un proceso que combina dos listas ordenadas preservando el orden. Examinemos la mezcla de dos listas ordenadas (asumiremos que nuestras listas contienen enteros y están ordenadas de forma creciente) antes de ver el papel de la mezcla en la ordenación. El proceso de mezcla se puede realizar seleccionando sucesivamente el valor más pequeño que aparece en cualquiera de las dos listas y moviendo dicho valor a una nueva lista, creando así una lista ordenada. Por ejemplo, mientras mezclamos las siguientes dos listas: Lista 1: Lista 2: 8 36 podemos obtener las siguientes trazas: Lista 1: Lista 2:36 Nueva Lista : 8 Lista 1: Lista 2:36 Nueva Lista : 8 13 Lista 1: 58 Lista 2:36 Nueva Lista : Lista 1: 58 Lista 2 : Nueva Lista : Introducción a la Recursión. Pág 14

15 Lista 1: Lista 2: Nueva Lista : Si estas dos listas se almacenan en el mismo array, dicho array tendrá el siguiente aspecto: Lista: Primero Mitad Ultimo donde los elementos Primero a Mitad-1 representan a la Lista1, mientras que los elementos Mitad a Ultimo representa a la Lista2. En el proceso de mezcla, se va a necesitar un área temporal (Temp),del mismo tamaño que la Lista, para almacenar los resultados. Al final, Temp se volverá a copiar en la Lista. El procedimiento para realizar la operación de mezcla se ilustra a continuación: void MezclaSimple(Lista &K, int Primero, int Mitad, int Ultimo) // Mezcla dos listas que están ordenadas en el mismo array Lista Temp; int Indice1, Indice2, IndiceMezcla, i; Indice1 = Primero; Indice2 = Mitad; // Inicializa el número de elementos en Temp IndiceMezcla = 0; /* Mientras haya elementos en cualquier parte de las listas ordenadas, mezclalos */ while((indice1 < Mitad) && (Indice2<= Ultimo)) IndiceMezcla++; if (K[Indice1] <= K[Indice2]) Temp[IndiceMezcla] = K[Indice1]; Indice1++; Temp[IndiceMezcla] = K[Indice2]; Indice2++; /* En este punto o la primera parte o la segunda parte está agotada. Copiamos cualquier parte remanente de la segunda parte a Temp. */ while (Indice2 <= Ultimo) IndiceMezcla++; Temp[IndiceMezcla] = K[Indice2]; Indice2++; // Copiamos cualquier parte que quede de la primera parte a Temp Introducción a la Recursión. Pág 15

16 while (Indice1 < Mitad) IndiceMezcla++; Temp[IndiceMezcla] = K[Indice1]; Indice1++; for (i=1 ;i<=indicemezcla; i++) K[Primero+i-1] = Temp[i]; /* Copiamos Temp en el array K*/ Este proceso de mezcla simple se puede generalizar para mezclar K listas ordenadas en una sola lista ordenada. A este proceso se le llama mezcla múltiple. La mezcla múltiple se puede llevar a cabo realizando una mezcla simple, repetidamente. Por ejemplo, si tenemos ocho listas para mezclar, podemos mezclarlas a pares para obtener así cuatro listas ordenadas. Estas listas, a su vez, se pueden mezclar a pares para obtener dos listas ordenas. Y una operación de mezcla final nos dará la lista ordenada. Veamos ahora como se puede usar la mezcla para ordenar un array de ocho elementos. Asumimos que la lista contiene: Dividamos esta lista en dos partes iguales (una barra vertical indica el punto de división). Obtenemos: Como no están ordenadas, no podemos mezclar estas dos listas. Dividamos la primera sublista en dos piezas: Una vez más: La primeras dos sublistas contienen sólo un elemento, y obviamente una lista que contiene un solo elemento está ordenada(!). Esto significa que se pueden mezclar estas dos obteniendo Ahora, si la parte B de esta lista se divide en dos partes y las listas resultantes formadas por elementos simples se mezclan, obtenemos: Como las dos primeras listas están ahora ordenadas, podemos mezclarlas : Como puedes ver, la primera mitad del array ya está ordenada. Si aplicamos la misma técnica a la segunda sublista y después las mezclamos con la primera, estará ordenado todo el array. En el Introducción a la Recursión. Pág 16

17 Ejemplo 7, el procedimiento OrdenacionPorMezcla divide el array de entrada en sublistas más y más pequeñas hasta que alcancen el tamaño de un elemento. Entonces, usando el procedimiento MezclaSimple, se mezclan esas sublistas, obteníendose la lista ordenada. Ejemplo7. Programa recursivo para la ordenación por mezcla. /************************************************** * Autor: * Fecha: Versión: ***************************************************/ #include <iostream.h> #include <stdlib.h> const int Tamanyo = 10; // Tamaño del array typedef int Lista[Tamanyo]; void MezclaSimple(Lista &K, int Primero,int Mitad,int Ultimo) // Mezcla dos listas que están ordenadas en el mismo array // El cuerpo del procedimiento anterior void OrdenacionPorMezcla(Lista &K,int Primero, int Ultimo) // Ordena el array K usando ordenación por mezcla recursiva int Tam, Mitad; // Determina el tamaño de la porción actual Tam = Ultimo - Primero + 1; if (Tam <= 1) // No más divisiones return; // Divide en dos y ordena Mitad = Primero + Tam / 2-1; OrdenacionPorMezcla(K, Primero, Mitad); OrdenacionPorMezcla(K, Mitad+1, Ultimo); // Mezcla ambas mitades ordenadas MezclaSimple(K, Primero, Mitad+1,Ultimo); int main() Lista Desordenado; int Elemento,Primero, Segundo, Tercero, i, K; i = 0; // Entrada de datos desordenados cin >> K; while(i < Tamanyo-1) i++; Desordenado[i] = K; Cin >> K; Tercero = i; OrdenacionPorMezcla(Desordenado, 1, Tercero); for( i = 1; i<=tercero; i++) // Imprime el array ordenado cout<<desordenado[i]<<endl; system("pause"); return 0; Introducción a la Recursión. Pág 17

18 EJERCICIOS 1.- Cual será la salida del siguiente programa?. Intenta resolverlo primero sobre papel. #include <iostream.h> #include <stdlib.h> void ImprimeResto() const char Punto='.'; char X; cin >> X; if (X!= Punto) ImprimeResto(); cout << X; int main() ImprimeResto(); cout << endl; system("pause"); return 0; si la entrada es : Si algo puede salir mal, saldrá mal. 2.- Cual será la salida del siguiente programa?. Intenta resolverlo primero sobre papel. #include <iostream.h> #include <stdlib.h> int Uno(int A, int B) if (B!= 0) A++; B--; return Uno(A,B); return A ; int main() cout << Uno(5,6) << endl; system("pause"); return 0; Introducción a la Recursión. Pág 18

19 3.- La relación recurrente x n 1 si n = 0 n 1 = x * x si n > 0 n+ 1 x / x si n < 0 define x como la potencia n-ésima de todos los enteros. Escribir un procedimiento recursivo llamado Potencia que calcule x a la n-ésima potencia para un entero x. Introducción a la Recursión. Pág 19

20 4.- El máximo común divisor de dos enteros positivos M y N se puede definir como: N si N M y M mod N = 0 MCD( M, N ) = MCD( N, M) si M < N MCD( N, M mod N ) en otro caso Escribir una función recursiva que permita calcular el máximo común divisor de dos enteros positivos. 7.- En general, el N-ésimo término de la sucesión de Fibonacci, se define como: A si N = 1 F( A, B, N) = B si N = 2 F( B, A + B, N 1) si N > 2 Donde A y B son los números que originan la secuencia. Escribir un programa que compute el N- ésimo término de la sucesión de Fibonacci usando diferentes números para originar la secuencia. 8.- La función Q se define como: 1 si N 2 Q( N ) = Q( N Q( N 1)) si N > 2 Escribir dos procedimientos, uno recursivo y otro no recursivo, para computar el valor de esta función para varios valores de N. Puedes escribir una función que haga uso de más memoria para así aumentar la velocidad de los cálculos recursivos?. 9.- El valor del N-ésimo término del polinomio de Legendre se puede calcular usando las siguientes fórmulas: P 0 (x) = 1 P 1 (x) = x P 2* N 1 N 1 ( x) = * x * P 1( x) * P 2 ( x) N N N N N Escribir una furnción recursiva que compute el N-ésimo término del polinomio de Legendre. Introducción a la Recursión. Pág 20

21 10.- Escribir una función recursiva para computar la función de Ackermann, la cual se define como: N + 1 si M = 0 A(M,N) = A(M 1,N) si M 0 and N = 0 A(M -1,A(M,N -1)) si M 0 and N 0 donde M y N son números cardinales Para cualesquiera enteros no negativos N y K, donde 0<=K<=N, el coeficiente binomial C(N,K) se define como: C( N, K) = N! K!* ( N K)! Esta fórmula verifica que: 1. C(N,K) = C(N, N-K); es decir, la lista de coeficientes binomiales es simétrica con respecto a su valor central. 2. C(N,N) = 1 y por simetría C(N,0) = C(N,N-1)=N y por simetría C(N,1) = N. El problema para computar C(N,K) haciendo uso de la fórmula anterior estriba en que N! crece muy rápidamente.por lo que necesitamos un método alternativo para calcular dichos coeficientes. Para ello podemos hacer uso del hecho de que para cualquier K que satisfaga 1<=K<=N-1: C( N, K) = C( N, K 1) * ( N K + 1) K Escribir un programa que calcule el coeficiente binomial C(N,K) para varios N y K Un programa bastante popular es hacer que un ratón encuentre un queso de cabrales en un laberinto. Vamos a suponer que el laberinto es un recinto rectangular dividido en cuadrados, estando cada cuadrado ocupado por un obstáculo o libre. El perímetro del rectángulo está ocupado por obstáculos, excepto en una o más salidas. Comenzamos en algún lugar dentro del laberinto, y tenemos que encontrar el camino de salida. Podemos movernos de cuadrado en cuadrado en cualquier dirección (excepto diagonalmente), pero no podemos atravesar un obstáculo. Podemos representar el laberinto en un ordenador mediante un array de caracteres ( o booleano) bidimensional, por ejemplo: BBBBBBBBBBBB B..BBB...BB BB...B.BBB.B B..B.B.B...B BBB...BBBBB B...BBB...B B.B...BB.B BBBBBBBBBB.B Construir un programa recursivo que tenga como entrada la posición del ratón dentro del laberinto y que determine una de sus posibles salidas. Introducción a la Recursión. Pág 21

22 (* El siguiente ejercicio no se debe incluir en la relación de problemas *) 12.- El método de ordenación rápida (QuickSort) es un método de ordenación rápido y relativamente moderno desarrollado por Hoare. Es esencialmente un esquema de inserción/intercambio que, en cada etapa, coloca al menos un elemento en su sitio adecuado. Saber que este elemento está bien posicionado se usa para reducir el número de comparaciones que se necesitan para posicionar el resto de elementos. La filosofía del QuickSort consiste en dividir la lista de elementos tomando como referencia un determinado elemento, llamado pivote, de forma que, en las listas resultantes de la división, todas los elementos que precedan al pivote sean menores o iguales al mismo y todos los elementos que estén después del pivote sean mayores o iguales que el mismo. Izqda IFin Dinicio Dcha... pivote pivote pivote Como resultado de la partición, el pivote está correctamente colocado. El mismo proceso de partición se aplica entonces a las dos sublistas a ambos lados del pivote. De esta forma la lista original es sistemáticamente reducida a una serie de sublistas, cada una de longitud uno, que están, por supuesto, ordenadas y, más importante, correctamente posicionadas en relación a las otras. La característica más importante de este algoritmo es la partición. La entrada seleccionada como el pivote suele ser la primera entrada. Habiendo elegido el pivote, el algoritmo busca en la lista,desde dicho pivote hasta el final, el primer elemento que no pertenezca a ese lado del pivote. Estos dos elementos se intercambian, y se reanuda la búsqueda con los elementos adyacentes. Cuando coinciden dos búsquedas, el pivote está posicionado entre dos sublistas en orden para mantener la ordenación relativa. Dados los índices de los elementos más a la izquierda (Izquierda) y a la derecha (Derecha) de la sublista a ordenar, el algoritmo queda como: SI Izquierda < Derecha parte Lista[Izquierda] a Lista[Derecha] en dos secciones más pequeñas de forma que: Lista[Izquierda]...Lista[Final] <= Lista[Pivote] <= Lista[DechaInicio]... Lista[Derecha] ordena Lista[Izquierda]...Lista[Final] ordena Lista[DechaInicio]...Lista[Derecha] Escribir un programa que ordene una lista de enteros usando este método. Introducción a la Recursión. Pág 22