Te interesan los algoritmos recursivos?? Estás teniendo problemas para resolver algún ejercicio que te han plateado?? Sea como fuere, has llegado al lugar indicado, estoy encantado de tenerte por aquí. Pero antes de nada, un poquito de teoría.
Qué es un algoritmo recursivo?
Un algoritmo recursivo es aquel que resuelve un problema mediante llamadas sucesivas a sí mismo.
Aquí os dejo una serie de ejercicios de JAVA para practicar la recursión. Es recomendable intentar hacer primero el ejercicio sin mirar la solución.
Los ejercicios de recursión suelen costar de entender al principio. No te agobies si no no terminas de entender muy bien el funcionamiento, es perfectamente normal.
Te recomiendo que hagas siempre un seguimiento del programa, de este modo podrás comprobar el orden de llamadas del método recursivo. Puedes hacerlo utilizando el depurador o imprimiendo por pantalla mensajes en determinadas partes del algoritmo, ánimo!!
PD. Para resolver este tipo de problemas siempre hay distintas formas de hacerlo. Si piensas que tienes alguna solución más interesante para cualquiera de los ejercicios, puedes dejarla en los comentarios.
Los métodos recursivos son aquellos que se invocan a si mismos dentro del propio cuerpo del método.
Ejercicio 1
Crea un método que obtenga la suma de los números naturales desde 1 hasta N. Se debe pasar como parámetro el número N
//by aulaenlanube.com
public static void main(String[] args)
{
//llamada para obtener la suma de 5
System.out.println(sum(4));
}
//método que devuelve la suma de los elementos desde n hasta 1
//ejemplo: n = 4 -> 4+3+2+1=10
static int sum(int n)
{
//caso base
if(n==1)
return 1;
//llamada recursiva
else
return n+sum(n-1);
}
Ejercicio 2
Crea un método que imprima los dígitos desde 1 hasta N. Se debe pasar como parámetro el número N
//by aulaenlanube.com
public static void main(String[] args)
{
//cantidad de dígitos
int n = 5;
incre(n);
}
//método que imprime dígitos de 1 hasta n
//ejemplo: n=5 -> 12345
//ejemplo: n=8 -> 12345678
static void incre(int n)
{
if(n>0)
{
incre(n-1);
System.out.print(n);
}
else
System.out.println();
}
Ejercicio 3
Crea un método que imprima los dígitos desde N hasta 1. Se debe pasar como parámetro el número N
//by aulaenlanube.com
public static void main(String[] args)
{
int n = 5;
decre(n);
}
//método que imprime dígitos de n hasta 1
//ejemplo: n=5 -> 54321
//ejemplo: n=8 -> 87654321
static void decre(int n)
{
if(n>0)
{
System.out.print(n);
decre(n-1);
}
else
System.out.println();
}
Ejercicio 4
Crea un método que obtenga la cantidad de dígitos de un número N. Se debe pasar como parámetro el número N
//by aulaenlanube.com
public static void main(String[] args)
{
int n = 1111;
System.out.println(n+" tiene "+digi(n)+" dígitos");
}
//método que devuelve la cantidad de dígitos de num, num debe ser positivo
//ejemplo: num = 1111 -> 4
//ejemplo: num = 45895 -> 5
static int digi(int num)
{
if(num<=0) return 0;
return 1 + digi(num/10);
}
Ejercicio 5
Crea un método que obtenga el factorial de un número N. Se debe pasar como parámetro el número N
//by aulaenlanube.com
public static void main(String[] args)
{
//obtier factorial de n
int n = 4;
System.out.println(n+"! = "+fact(n));
}
//método que devuelve el factorial de n
//ejemplo: n = 4 -> 4x3x2x1
static int fact(int n)
{
if(n>1) return n * fact(n-1);
else return 1;
}
Ejercicio 6
Crea un método que calcule el número de fibonacci a partir de un número pasado como parámetro
//by aulaenlanube.com
public static void main(String[] args)
{
//numero de fibonacci
int num = 5;
System.out.println("Fibonacci de "+num+" es "+fibonacci1(num));
System.out.println("Fibonacci de "+num+" es "+fibonacci2(num));
System.out.println("Fibonacci de "+num+" es "+fibonacci3(num));
}
//solución 1
static int fibonacci1(int n)
{
if (n>1) return fibonacci1(n-1) + fibonacci1(n-2); //función recursiva
else if (n==1)
return 1;
else
return 0;
}
//solución 2
static int fibonacci2(int n)
{
if (n>1)
return fibonacci2(n-1) + fibonacci2(n-2); //función recursiva
else return n;
}
//solución 3
static int fibonacci3(int n)
{
if (n<2)
return n;
else return fibonacci3(n-1) + fibonacci3(n-2); //función recursiva
}
Ejercicio 7
Crear un método que obtenga el resultado de elevar un número a otro. Ambos números se deben pasar como parámetros
//by aulaenlanube.com
public static void main(String[] args)
{
int base=2;
int exp=0;
System.out.println(base+" elevado a "+exp+" = "+poten(base, exp));
}
//método que devuelve base elevado a exp
//ejemplo: base = 2 y exp = 4 -> 4
static int poten(int base, int exp)
{
if(exp==0) return 1; // cualquier número elevado a cero es 1
else if(exp==1) return base;
else return base * poten(base,exp-1);
}
Ejercicio 8
Crea un método que dado un número, lo imprima invertido por pantalla
//by aulaenlanube.com
public static void main(String[] args)
{
//numero a invertir
int n = 1234;
inv(n);
}
//método que dado un número, lo imprime por pantalla invertido
//ejemplo: n = 1234 -> 4321
static void inv(int n)
{
if(n<10) System.out.print(n);
else
{
System.out.print(n%10);
inv(n/10);
}
}
Ejercicio 9
Crea un método que imprima por pantalla un Rectángulo a partir de los valores de la base y la altura
//by aulaenlanube.com
public static void main(String[] args)
{
//imprimir rectángulo: altura, base
cuad(5,10);
}
//método que imprime un rectángulo
//ejemplo: base = 4 y altura 3
//
// * * * *
// * * * *
// * * * *
//
static void cuad(int altura, int base)
{
if(altura>0)
{
cuad2(base);//método recursivo que crea los elementos de cada línea
cuad(altura-1, base);//llamada recursiva
}
}
//crea los elementos de cada línea
static void cuad2(int n)
{
if(n>0)
{
System.out.print("* ");
cuad2(n-1);
}
else
System.out.println();
}
Ejercicio 10
Crea un método que imprima por pantalla un Triángulo rectángulo a partir del valor de la altura del triángulo
//by aulaenlanube.com
public static void main(String[] args)
{
//tamaño del triángulo
int n = 5;
//tipo de triángulo: 1-creciente 2-decreciente
int tipo = 1;
if(tipo==1) tri_tipo1(n);
else if (tipo==2) tri_tipo2(n);
}
//crea los elementos de cada fila
static void trian(int n)
{
if(n>0)
{
System.out.print("* ");
trian(n-1);
}
else
System.out.println();
}
//triángulo rectángulo creciente
static void tri_tipo1(int n)
{
if(n>0)
{
tri_tipo1(n-1);
trian(n);
}
}
//triángulo rectángulo decreciente
static void tri_tipo2(int n)
{
if(n>0)
{
trian(n);
tri_tipo2(n-1);
}
}
Ejercicio 11
Crea un método que compruebe si una palabra está ordenada alfabéticamente
//by aulaenlanube.com
public static void main(String[] args)
{
//palabra analizada
String palabra="abcdef";
if(orden(palabra)) System.out.println("La palabra está ordenada alfabéticamente");
else System.out.println("La palabra NO está ordenada alfabéticamente");
}
//método que comprueba si una palabra está ordenada alfabéticamente
//ejemplo: abcdef -> true
public static boolean orden(String cad)
{
cad=cad.toLowerCase();
if(cad.length()>1)
{
if(cad.charAt(0)<=cad.charAt(1))
return orden(cad.substring(1, cad.length()));
else return false;
}
else return true;
}
//by aulaenlanube.com
public static void main(String[] args)
{
//palabra analizada
String s="reconocer";
if(palin(s)) System.out.println("Es un palíndromo");
else System.out.println("No es un palíndromo");
}
//método que comprueba si una palabra es un palíndromo
//ejemplo: reconocer -> true
public static boolean palin(String frase)
{
frase=frase.toLowerCase();
if(frase.length()<=1) return true;
else
{
if(frase.charAt(0)==frase.charAt(frase.length()-1))
return palin(frase.substring(1, frase.length()-1));
else return false;
}
}
Ejercicio 13
Crea un método que obtenga el número binario de un número N pasado como parámetro binario
//by aulaenlanube.com
public static void main(String[] args)
{
//número a convertir
int N=10;
binario(N);
System.out.println();
System.out.println(binario2(N));
}
//solución1: método que imprime por pantalla n en binario
public static void binario(int n)
{
if(n<2) System.out.print(n);
else
{
binario(n/2);
System.out.print(n%2);
}
}
//solución2: método que devuelve el binario de n
public static int binario2(int n)
{
if(n<2) return n;
else
return n%2+10*binario2(n/2);
}
Ejercicio 14
Crea un método que compruebe si un número es binario. Un número binario está formado únicamente por ceros y unos
//by aulaenlanube.com
public static void main(String[] args)
{
//valor del número analizado
int num = 1001010;
if(enBinario(num)) System.out.println("El número está en binario");
else System.out.println("El número no está en binario");
}
//método que comprueba si n está en binario
//ejemplo: n = 101011 -> true
static boolean enBinario(int n)
{
if(n>9)
{
if(n%10==0 || n%10==1) return enBinario(n/10);
else return false;
}
else if(n==0 || n==1) return true;
else return false;
}
Ejercicio 15
Crea un método que compruebe si un número está ordenado de forma decreciente y creciente
//by aulaenlanube.com
public static void main(String[] args)
{
//valor del número analizado
int num = 4121;
//creciente
if (ordenado_cre(num))
System.out.println("Está ordenado de forma creciente");
else
System.out.println("NO está ordenado de forma creciente");
//decreciente
if (ordenado_decre(num))
System.out.println("Está ordenado de forma decreciente");
else
System.out.println("NO está ordenado de forma decreciente");
}
//obtiene base elevado a exp
static int poten(int base, int exp)
{
if(exp==0) return 1;
else return base * poten(base,exp-1);
}
//obtiene la cantidad de dígitos de num
static int digitos(int num)
{
if(num==0) return 0;
return 1 + digitos(num/10);
}
//comprueba si un num está ordenado de forma creciente
//ejemplo: num = 1234 -> true
static boolean ordenado_cre(int num)
{
if(num<10) return true;
else
{
int num_izq = num / poten(10, digitos(num)-1);
num = num - num_izq*poten(10, digitos(num)-1);
int num_der = num / poten(10, digitos(num)-1);
if(num_izq<=num_der) return ordenado_cre(num);
else return false;
}
}
//comprueba si un num está ordenado de forma decreciente
//ejemplo: num = 4321 -> true
static boolean ordenado_decre(int num)
{
if(num<10) return true;
else
{
int num_izq = num / poten(10, digitos(num)-1);
num = num - num_izq*poten(10, digitos(num)-1);
int num_der = num / poten(10, digitos(num)-1);
if(num_izq>=num_der) return ordenado_decre(num);
else return false;
}
}
Ejercicio 16
Crea un método que compruebe si un número es simétrico. Los números simétricos son iguales a partir del dígito central pero comparando en dirección opuesta
//by aulaenlanube.com
public static void main(String[] args)
{
//valor del número analizado
int num = 1321;
if (simetric(num))
System.out.println("Es simétrico");
else
System.out.println("NO es simétrico");
}
//método que devuelve la cantidad de dígitos de num
static int digitos(int num)
{
if(num==0) return 0;
return 1 + digitos(num/10);
}
//método que devuelve base elevado a exp
static int poten(int base, int exp)
{
if(exp==1) return base;
else return base * poten(base,exp-1);
}
//método que comprueba si num es un número es simétrico
//ejemplo: num = 12321 -> true
static boolean simetric(int num)
{
if(digitos(num)<=1)
return true;
else
{
int desp = poten(10,digitos(num)-1);
if(num/desp != num % 10)
return false;
else
return simetric((num-(num/desp)*desp)/10);
}
}
