Ejemplo de Recursividad

Recursividad de un numero Factorial y Pontencia

Este Es un ejemplo de la recursividad en java:

import java.io.*;
public class Recursion{
public static BufferedReader entrada=new BufferedReader(new InputStreamReader(System.in));
public static void main(String[ ] args)throws IOException{
Menu();
}
public static void Menu()throws IOException{
System.out.println(“\n”);
System.out.println(“^_^_^_^_^_^_^_^_^_^_^_^_^_^_^”);
System.out.println(” 1- Factorial de un numero “);
System.out.println(” 2- Potencias “);
System.out.println(“^_^_^_^_^_^_^_^_^_^_^_^_^_^_^”);
System.out.print(“Opcion : “);
int opc = Integer.parseInt(entrada.readLine());
Opciones( opc ); // @ver >> metodo opciones
}
public static void Opciones (int o)throws IOException{
switch( o ){
case 1: Factorial();
break;
case 2: Potencia();
break;
default: System.exit(1);
break;
}
}
public static void Factorial()throws IOException{
System.out.print(“Digite el numero al que desea calcular su factorial: “);
int n = Integer.parseInt(entrada.readLine());
int r = factorial(n);
System.out.println(“El factorial de “+n+” es “+r);
Menu();
}
public static int factorial(int n)throws IOException{
if ( (n==0) || (n==1) ){
return 1;
} else{
return n*factorial(n-1); // Esta es la Recursividada Esta Llamando al mismo metodo
}
}
public static void Potencia()throws IOException{
System.out.print(“Digite la base: “);
int b = Integer.parseInt(entrada.readLine());
System.out.print(“Digite el exponente: “);
int p = Integer.parseInt(entrada.readLine());
int r = potencia(b,p);
System.out.println(“El resultado de elevar “+b+” al”+p+” es: “+r);
Menu();
}
public static int potencia(int b,int p)throws IOException{
if (p == 0){
return 1;
}
if (p == 1){
return b;
}else{
return b * potencia( b , p-1); //Esta es la Recursividada Esta Llamando al mismo metodo
}
}
}

Recursividad-Por Garo Chavez

La recursividad es una técnica de programación importante. Se utiliza para realizar una llamada a una función desde la misma función.

Un requisito importante para que sea correcto un algoritmo recursivo es que no genere una secuencia infinita de llamadas así mismo. Claro que cualquier algoritmo que genere tal secuencia no termina nunca. Una función recursiva f debe definirse en términos que no impliquen a f al menos en un argumento o grupo de argumentos. Debe existir una "salida" de la secuencia de llamadas recursivas.

Usualmente los lenguajes de programación permiten definir funciones de manera recursiva. El lenguaje C es uno de ellos. La definición recursiva para el factorial sería:

int factorial(int n) {
      if ((n == 0) || (n == 1))
         return(1);
      else
         return(n*factorial(n-1));
   }

Normalmente las definiciones recursivas pueden expresarse en forma no recursiva. Sin embargo, dependiendo del caso, el resultado puede ser más confuso. Por ejemplo, una función en C que calcula el factorial en forma iterativa sería:

int factorial(int n) {
      int i, fact = 1;

      for (i=2; i<=n; i++)
         fact = fact * i;
      return(fact);
   }

Ejemplos:

• Factorial -- n! = n × (n-1)!
• Sucesión de Fibonacci -- f(n) = f(n-1) + f(n-2)
• Números de Catalan -- C(2n, n)/(n+1)
• Las Torres de Hanói
• Función de Ackermann