▷ Ejercicios resueltos de recursividad en JAVA

Los métodos recursivos son aquellos que se invocan a si mismos dentro del propio cuerpo del método.

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.

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;       
}    
				
			

Ejercicio 12

Crea un método que compruebe si una palabra es un palíndromo
				
					//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);
    }  
} 
				
			
Icono cookies
Icono cookies

Utilizamos cookies para asegurar que damos la mejor experiencia al usuario. Si continúa navegando, consideramos que acepta nuestro uso de Cookies. Puede obtener más información en nuestra política de Cookies

Utilizamos cookies para asegurar que damos la mejor experiencia al usuario. Si continúa navegando, consideramos que acepta nuestro uso de Cookies. Puede obtener más información en nuestra política de Cookies