Recursion mutua, limites reales y cuando no usarla.
Dos metodos que se llaman entre si. No hay ninguna magia extra: la pila alterna marcos de uno y de otro. Aparece de forma natural en analizadores sintacticos, donde expresion() llama a termino() y termino() vuelve a llamar a expresion() dentro de un parentesis.
static boolean esPar(int n) {
if (n == 0) return true;
return esImpar(n - 1);
}
static boolean esImpar(int n) {
if (n == 0) return false;
return esPar(n - 1);
}
El limite no se mide en llamadas sino en bytes. Un metodo con muchas variables locales tiene marcos mas grandes y revienta antes. Puedes medirlo tu mismo con un contador y un try-catch de StackOverflowError.
El flag -Xss cambia el tamano de pila por hilo: java -Xss4m MiPrograma. Ojo: es por hilo, asi que en un servidor con miles de hilos multiplicar ese valor tiene un costo enorme.
static int profundidad = 0;
static void medir() {
profundidad++;
medir();
}
public static void main(String[] args) {
try {
medir();
} catch (StackOverflowError e) {
System.out.println("Reventó en: " + profundidad);
}
}
Un buen profesor tambien ensena a no usar la herramienta. No uses recursion cuando la profundidad depende del tamano del dato de entrada y ese dato puede ser grande. Recorrer una lista enlazada de un millon de nodos de forma recursiva es un error, aunque quede bonito.
Si el arbol esta balanceado la profundidad es log n y la recursion es perfectamente segura. Si el arbol puede degenerar en una linea, no lo es. Esa es la pregunta que hay que hacerse.
Un ciclo A llama a B, B llama a C, C llama a A puede colarse en cualquier proyecto grande sin que nadie lo note, hasta que en produccion llega un dato que lo dispara. Cuando veas un StackOverflowError con un rastro que se repite en bloque, es esto.
Cambia los parametros, dale a Reproducir, y usa las flechas para avanzar paso a paso. La pila crece hacia arriba: el marco de arriba es el que se esta ejecutando ahora mismo.
Lee el codigo, decide que esta mal, y despues abre la correccion.
static int contar(Nodo n) {
if (n == null) return 0;
return 1 + contar(n.siguiente);
}
La profundidad es igual al numero de nodos. Con una lista larga revienta la pila.
static int contar(Nodo n) {
int c = 0;
while (n != null) { c++; n = n.siguiente; }
return c;
}
Necesitas el 70% para dar el nivel por visto. Responde sin devolverte a la teoria: si fallas, la explicacion te dice exactamente donde estaba el hueco.