Recursividad en Java

¿Qué es la recursividad en Java?

La recursión en Java es una técnica de programación en la que un método llama a sí mismo para resolver un problema. Es una forma de dividir un problema complejo en problemas más pequeños y manejables.

Una de las ventajas de la recursión es que puede ser más fácil de entender y mantener en comparación con los ciclos o bucles. Sin embargo, también puede ser menos eficiente en términos de uso de memoria debido a la creación de una pila de llamadas.

Una característica importante de un método recursivo es que debe tener una o varias condiciones de salida o casos base que finalizan la recursión. Estas condiciones deben ser diseñadas cuidadosamente para evitar una recursión infinita.

Ejemplos

Aquí hay algunos ejemplos de problemas comunes que se pueden resolver mediante recursión en Java:

• Calcular el factorial de un número:

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

Lenguaje del código: Java (java)

• Calcular la suma de los elementos de una lista:

public int sumarLista(List<Integer> lista, int i) {
    if (i == lista.size()) {
        return 0;
    }
    return lista.get(i) + sumarLista(lista, i+1);
}

Lenguaje del código: Java (java)

• Calcular el n-ésimo número de Fibonacci:

public int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n-1) + fibonacci(n-2);
}

Lenguaje del código: Java (java)

• Encontrar un elemento en una lista ordenada:

public boolean buscarEnLista(List<Integer> lista, int elemento, int inicio, int fin) {
    if (inicio > fin) {
        return false;
    }
    int mitad = (inicio + fin) / 2;
    if (lista.get(mitad) == elemento) {
        return true;
    } else if (lista.get(mitad) < elemento) {
        return buscarEnLista(lista, elemento, mitad+1, fin);
    } else {
        return buscarEnLista(lista, elemento, inicio, mitad-1);
    }
}

Lenguaje del código: Java (java)

Es importante mencionar que en algunos casos, existen alternativas iterativas para resolver los mismos problemas de forma más eficiente en términos de uso de memoria y tiempo de ejecución. Sin embargo, la recursión puede proporcionar una solución más clara y concisa.

Otro ejemplo

Aquí te dejo otro ejemplo de un problema que se puede resolver utilizando recursión en Java. El problema consiste en encontrar la suma de los elementos de un arreglo de enteros.

public class SumaArreglo {
    public int sumar(int[] arreglo, int indice) {
        if (indice == arreglo.length) {
            return 0; // caso base: se ha llegado al final del arreglo
        }
        return arreglo[indice] + sumar(arreglo, indice + 1); // sumar el elemento actual y continuar sumando el resto del arreglo
    }

    public static void main(String[] args) {
        int[] arreglo = {1, 2, 3, 4, 5};
        SumaArreglo sumador = new SumaArreglo();
        int suma = sumador.sumar(arreglo, 0);
        System.out.println("La suma del arreglo es: " + suma);
    }
}

Lenguaje del código: Java (java)

En este ejemplo se define un método “sumar()” que toma como parámetros un arreglo de enteros y un índice. El método utiliza recursión para sumar los elementos del arreglo, uno por uno, empezando desde el índice dado.

El caso base es cuando el índice es igual al tamaño del arreglo, en cuyo caso se retorna 0 (ya que se ha llegado al final del arreglo y no hay más elementos para sumar). En cualquier otro caso, se suma el elemento actual del arreglo (arreglo[indice]) y se llama recursivamente al método “sumar()” con el índice aumentado en 1, para continuar sumando el resto del arreglo.

En el método main() se crea un objeto de la clase SumaArreglo, se define un arreglo de ejemplo y se llama al método sumar() pasando el arreglo y el índice inicial (0) como parámetros. Finalmente, se imprime el resultado de la suma en consola.

Este ejemplo es solo una posible solución al problema, hay otras formas de hacerlo, pero la recursividad es una forma limpia y clara de hacerlo.