Recursividad

Concepto
Recurrencia, recursión o recursividad es la forma en la cual se especifica un proceso basado en su propia definición. Siendo un poco más precisos, y para evitar el aparente círculo sin fin en esta definición:
Un problema que pueda ser definido en función de su tamaño, sea este N, pueda ser dividido en instancias más pequeñas (< N) del mismo problema y se conozca la solución explícita a las instancias más simples, lo que se conoce como casos base, se puede aplicar inducción sobre las llamadas más pequeñas y suponer que estas quedan resueltas.
Para que se entienda mejor a continuación se exponen algunos ejemplos:

• Factorial(x: Entero): Sea N := x el tamaño del problema, podemos definir el problema de forma recurrente como x*Factorial(x - 1); como el tamaño de Factorial(x - 1) es menor que N podemos aplicar inducción por lo que disponemos del resultado. El caso base es el Factorial(0) que es 1.

• Ordenación por fusión(v: vector): Sea N := tamaño(v), podemos separar el vector en dos mitades. Estas dos mitades tienen tamaño N/2 por lo que por inducción podemos aplicar la ordenación en estos dos subproblemas. Una vez tenemos ambas mitades ordenadas simplemente debemos fusionarlas. El caso base es ordenar un vector de 0 elementos, que está trivialmente ordenado y no hay que hacer nada.

En estos ejemplos podemos observar como un problema se divide en varias (>= 1) instancias del mismo problema, pero de tamaño menor gracias a lo cual se puede aplicar inducción, llegando a un punto donde se conoce el resultado (el caso base)..

Codigo


package fibonaci;
import java.util.*;
public class Fibonaci
{
    public int fibonacci(int n, int fibinf, int fibsup)
    {
        Scanner teclado = new Scanner(System.in);
        System.out.println("Ingrese el numero");
        n = teclado.nextInt();
        System.out.println("------------------------");
        if ((n==0)||(n==1))
        {
            System.out.println("La suma es: " + n);
            return n;
        }
   
    fibinf = 0;
    fibsup = 1;
    for(int i=2;i<n;i++)
    {
        int x;
        x = fibinf;
        fibinf = fibsup;
        fibsup = x + fibinf;
        System.out.println("" + fibsup);       
    }
    return (fibsup);
    }
    public static void main(String[] args)
    {
        Fibonaci fb = new Fibonaci ();
        int n=0, fibinf =0, fibsup=1;
        fb.fibonacci(n,fibinf, fibsup);
    }
}







package factorial;
import java.util.*;
public class Factorial
{
    public static double n, h;
    public static double factorial(double n)
    {
        if (n==0)
        {
            return 1;
        }
        else
            h = 1;
        return  n * factorial(n-1);
    }
   
    public static void main(String[] args)
    {
        System.out.println("¿Cual es el numero: ?");
        Scanner cap = new Scanner(System.in);
        n = cap.nextInt();
        if (n==0)
        {
            System.out.println("\nFactorial: 1");  
        }
        Factorial f = new Factorial();
        f.factorial(n);
        if(h==1)
        {
            System.out.println("\nFactorial= " + n * factorial (n-1));  
        }
    }
}







package numeros.negativos;
import java.util.Scanner;
public class NumerosNegativos
{
    public boolean positivo (int n)
    {
        if (n>0)
            return true;
        else
            return negativo (n);
    }
   
    public boolean negativo (int n)
    {
        if (n<0)
            return false;
        else
            return positivo(n);
    }
    public static void main(String[] args)
    {
        NumerosNegativos rec = new NumerosNegativos();
        Scanner teclado = new Scanner(System.in);
        int m;
        System.out.println("Ingrese el valor: ");
        m = teclado.nextInt();
        if (m == 0)
            System.out.println("true");
        else
            System.out.println(rec.positivo(m));
    }
}











Recursividad en JAVA