Recursividad: La recursividad es una tcnica de programacin importante.

Se utiliza para realizar una llamada a una funcin desde la misma funcin. Como ejemplo til se puede presentar el clculo de nmeros factoriales. l factorial de 0 es, por definicin, 1. Los factoriales de nmeros mayores se calculan mediante la multiplicacin de 1 * 2 * , incrementando el nmero de 1 en 1 hasta llegar al nmero para el que se est calculando el factorial. El siguiente prrafo muestra una funcin, expresada con palabras, que calcula un factorial. Si el nmero es menor que cero, se rechaza. Si no es un entero, se redondea al siguiente entero. Si el nmero es cero, su factorial es uno. Si el nmero es mayor que cero, se multiplica por l factorial del nmero menor inmediato. Para calcular el factorial de cualquier nmero mayor que cero hay que calcular como mnimo el factorial de otro nmero. La funcin que se utiliza es la funcin en la que se encuentra en estos momentos, esta funcin debe llamarse a s misma para el nmero menor inmediato, para poder ejecutarse en el nmero actual. Esto es un ejemplo de recursividad. La recursividad y la iteracin (ejecucin en bucle) estn muy relacionadas, cualquier accin que pueda realizarse con la recursividad puede realizarse con iteracin y viceversa. Normalmente, un clculo determinado se prestar a una tcnica u otra, slo necesita elegir el enfoque ms natural o con el que se sienta ms cmodo. Claramente, esta tcnica puede constituir un modo de meterse en problemas. Es fcil crear una funcin recursiva que no llegue a devolver nunca un resultado definitivo y no pueda llegar a un punto de finalizacin. Este tipo de recursividad hace que el sistema ejecute lo que se conoce como bucle infinito. Para entender mejor lo que en realidad es el concepto de recursin veamos un poco lo referente a la secuencia de Fibonacci. Principalmente habra que aclarar que es un ejemplo menos familiar que el del factorial, que consiste en la secuencia de enteros. 0,1,1,2,3,5,8,13,21,34,, Cada elemento en esta secuencia es la suma de los precedentes (por ejemplo 0 + 1 = 0, 1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, ) sean fib(0) = 0, fib (1) = 1 y as sucesivamente, entonces puede definirse la secuencia de Fibonacci mediante la definicin recursiva (define un objeto en trminos de un caso mas simple de si mismo): fib (n) = n if n = = 0 or n = = 1 fib (n) = fib (n - 2) + fib (n - 1) if n >= 2

Por ejemplo, para calcular fib (6), puede aplicarse la definicin de manera recursiva para obtener: Fib (6) = fib (4) + fib (5) = fib (2) + fib (3) + fib (5) = fib (0) + fib (1) + fib (3) + fib (5) = 0 + 1 fib (3) + fib (5) + fib (1) + fib (2) + fib(5) = + 1 + fib(0) + fib (1) + fib (5) = + 0 + 1 + fib(5) = 3 + fib (3) + fib (4) = + fib (1) + fib (2) + fib (4) = 3 + 1 + fib (0) + fib (1) + fib (4) = + 0 + 1 + fib (2) + fib (3) = 5 + fib (0) + fib (1) + fib (3) = + 0 + 1 + fib (1) + fib (2) = 6 + 1 + fib (0) + fib (1) = +0+1=8 Obsrvese que la definicin recursiva de los nmeros de Fibonacci difiere de las definiciones recursivas de la funcin factorial y de la multiplicacin . La definicin recursiva de fib se refiere dos veces a s misma . Por ejemplo, fib (6) = fib (4) + fib (5), de tal manera que al calcular fib (6), fib tiene que aplicarse de manera recursiva dos veces. Sin embargo calcular fib (5) tambin implica calcular fib (4), as que al aplicar la definicin hay mucha redundancia de clculo. En ejemplo anterior, fib(3) se calcula tres veces por separado. Sera mucho mas eficiente recordar el valor de fib(3) la primera vez que se calcula y volver a usarlo cada vez que se necesite. Es mucho mas eficiente un mtodo iterativo como el que sigue parar calcular fib (n). If (n < = 1) return (n); lofib = 0 ; hifib = 1 ; for (i = 2; i < = n; i ++) { x = lofib ;

lofib = hifib ; hifib = x + lofib ; } /* fin del for*/ return (hifib) ; Comprese el numero de adiciones (sin incluir los incrementos de la variable ndice, i) que se ejecutan para calcular fib (6) mediante este algoritmo al usar la definicin recursiva. En el caso de la funcin factorial, tienen que ejecutarse el mismo numero de multiplicaciones para calcular n! Mediante ambos mtodos: recursivo e iterativo. Lo mismo ocurre con el numero de sumas en los dos mtodos al calcular la multiplicacin. Sin embargo, en el caso de los nmeros de Fibonacci, el mtodo recursivo es mucho mas costoso que el iterativo.
partner-pub-8555 ISO-8859-1

*******************************************************

Este juego matemtico es clsico de los problemas de programacin. Hoy vamos a ver cmo calcular el nmero de movimientos necesarios para resolver el juego segn el nmero de discos, de forma recursiva en C++.
#include<stdio.h> int hanoi(int n) { if(n==1) return 1; else return 2 * hanoi(n-1) + 1; } int main() { int disc, mov; printf("::TORRES DE HANOI::\n"); printf("Numero de discos: ");scanf("%i",&disc); printf("\tMovimientos necesarios: %i\n", hanoi(disc)); return 0; }

Otro algoritmo raro. Lo que sabemos es que si tenemos 1 disco el nmero de movimientos es 1 y que ese es nuestro caso base (si n==1 retorna 1), a partir de ah el nmero de movimientos se puede calcular si multiplicamos por dos el nmero de movimientos para n1 y le sumamos 1, o sea: 2 + hanoi(n-1) + 1

Si son 2 discos, entonces 2 * hanoi(1) + 1 = 2 * 1 + 1 = 3 Si son 3 discos, entonces 2 * hanoi(2) + 1 = 2 * 3 + 1 = 7 etc

Sin comentarios

Recursividad aplicada: Mximo Comn Divisor

Guardado en: Programas el 20 de agosto del 2010 Etiquetas: recursividad Ooootro post sobre recursividad, pero no se preocupen ya solo queda este y otro. Esta vez vamos a calcular el mximo comn divisor de dos nmeros de forma recursiva en c++.
#include<stdio.h> int MCD(int x, int y) { if(y==0) return x; else return MCD(y, x%y); } int main() { int num1=0,num2=0; printf("::MAXIMO COMUN DIVISOR::\n"); printf("Introduce el primer numero: ");scanf("%i",&num1); printf("Introduce el segundo numero: ");scanf("%i",&num2); printf("\tEl resultado es: %i\n", MCD(num1, num2)); return 0; }

Este es uno de esos algoritmos recursivos raros o, mejor dicho, difciles de comprender, mi cerebro estuvo un buen rato echando humo tratando de comprender la lgica con que lo armaron y mi conclusin es que funciona de pura rana. Bueno, al final si supe como funciona pero no porque. 4 Comentarios

Recursividad aplicada: Serie de Fibonacci

Guardado en: Programas el 17 de agosto del 2010 Etiquetas: fibonacci, recursividad 0, 1, 1, 2, 3, 5, 8, 13, 21, , la serie de Fibonacci es bastante interesante e incluso aparece en la naturaleza. Comienza con un 0, luego un 1 y a partir de ah cada nmero es la suma de los dos siguientes. Eso ltimo nos indica recursividad. Veamos como mostrar n nmeros de la serie de Fibonacci de forma recursiva en C++.
#include<stdio.h> int fibonacci(int n) { if (n<2) return n; else return fibonacci(n-1) + fibonacci(n-2);

} int main() { int num=0,res=0; printf("::NUMEROS DE FIBONACCI::\n"); printf("Introduce el numero de numeros: ");scanf("%i",&num); printf("\t"); for(int i=0;i<=num-1;i++) { res = fibonacci(i); printf("%i ", res); } printf("\n"); return 0; }

Es la primera vez que vemos un la llamada a la funcin dentro de un ciclo. Eso es porque la funcin calcula el n-simo nmero de la serie, y para mostrarlos todos tenemos que hacer un ciclo que repita la funcin tantas veces como sea necesario. 14 Comentarios

Recursividad aplicada: Convertir Decimal a Binario

Guardado en: Programas el 14 de agosto del 2010 Etiquetas: binario, recursividad Siguiendo con esto de la recursividad hoy les traigo un nuevo programn, Convertir Decimal a Binario de forma recursiva.
#include<stdio.h> void binario(int n) { if (n!=0) { binario(n/2); printf("%i",n%2); } } int main() { int num=0; printf("::CONVERTIR DECIMAL A BINARIO::\n"); printf("Introduce un numero: ");scanf("%i",&num); //Pedir variable num printf("\t");binario(num);printf("\n"); //Llamar la funcin return 0; }

Est basado en el mtodo que usamos para convertir un nmero decimal a binario a mano: dividir el nmero entre dos hasta que quede 0 y apuntar los residuos del ltimo al primero.

2 Comentarios

Recursividad aplicada: Factorial

Guardado en: Programas el 11 de agosto del 2010 Etiquetas: factorial, recursividad Hola de nuevo, cunto tiempo pas? mmm no s pero bueno lo importante es que ya estoy de vuelta y ahora s me voy a dar el tiempo de actualizar este blog ms seguido, pero basta de cosas personales. No me quiero meter en rollos de explicar lo que es la recursividad (googleen y divirtanse leyendo), lo que quiero es mostrarles algunos ejemplos muy sencillos de dnde podemos aplicar la recursividad. Hoy toca calcular el factorial de un numero de forma recursiva. Es el cdigo recursivo ms fcil que se pueden encontrar:
#include<stdio.h> int factorial(int n) { if(n<2) return 1; else return n * factorial(n-1); } int main() { int num=0; printf("::CALCULAR FACTORIAL::\n"); printf("Introduce un numero: ");scanf("%i",&num); //Pedir variable num printf("\tEl resultado es: %i\n", factorial(num)); //Llama la funcion e imprime resultado return 0; }