Mi resultado esperado fue que no se imprimirá nada

En el siguiente ejemplo, si trato de leer el código xMethod (5), ya que es una función recursiva cuando = 0, es decir, xMethod (0) esperaba que no entrara en la instrucción if.

Mi expectativa para este código era que no debería haber una salida ya que la declaración de impresión es posterior al método recursivo

public class recursionThree {

    public static void main(String[] args) {
        xMethod(5);
    }

    public static void xMethod(int n){
        if (n > 0){
            xMethod(n-1);
            System.out.print(n + " ");
        }
    }
}
2
Nabeel A.Rahman 25 feb. 2018 a las 10:54

5 respuestas

La mejor respuesta

Los métodos no solo se llaman y no regresan. devuelven a la persona que llama.

Como ya sabrá, los métodos, cuando se los llama, se envían a una pila de llamadas. Entonces, cuando llamas a xMethod(5), llama a xMethod(4) y eso llama a xMethod(3) ... creando una pila de llamadas como esta:

xMethod(0)
xMethod(1)
xMethod(2)
xMethod(3)
xMethod(4)
xMethod(5)
main

Ahora, ¿qué hace xMethod(0)? No entra en la instrucción if, por lo que regresa de inmediato. Cuando un método regresa, se extrae de la pila de llamadas , y el control vuelve a lo siguiente en la pila. Ahora tenemos:

xMethod(1)
xMethod(2)
xMethod(3)
xMethod(4)
xMethod(5)
main

¿Recuerdas que todavía estamos en la línea xMethod(n-1); en el marco de la pila xMethod(1)? Desde que xMethod(n-1) regresó, podemos continuar ejecutando el resto del código. Por lo tanto, System.out.print se llama con n siendo 1 (¡todavía estamos en el marco de la pila xMethod(1)!).

Ahora xMethod(1) termina de ejecutarse y regresa y se saca de la pila. El control está de vuelta en xMethod(2). Y el ciclo continúa, hasta que xMethod(5) regrese.

0
Sweeper 25 feb. 2018 a las 08:05

La mejor manera de entender la recursividad es considerar las llamadas recursivas como una caja negra que hace lo que se supone que deben hacer.

Entonces su xMethod imprime los números del 1 al n. Para ello, imprime primero los números 1 a n-1 (utilizando la llamada recursiva) y luego imprime el número n.

0
Henry 25 feb. 2018 a las 08:40

En su código, la pila generará 5 cuadros para estas 5 llamadas recursivas de xMethod. Antes de que finalice cada llamada, System.out.print (n + "") puede imprimir la variable n en el marco. su pila de memoria se ve así

 ---------
|   n=1   |
 ---------
|   n=2   |
 ---------
|   n=3   |
 ---------
|   n=4   |
 ---------
|   n=5   |
 ---------

Cada cuadro es un marco, y cada marco se limpiará de arriba a abajo, por lo que la salida sería 1 2 3 4 5

0
陈敏华 25 feb. 2018 a las 08:07

Necesita pasar por el programa:

  • Llamar a xMethod(5) desde main
    • n > 0, por lo que llama xMethod(4)
      • n > 0, por lo que llama xMethod(3)
        • n > 0, por lo que llama xMethod(2)
          • n > 0, por lo que llama xMethod(1)
            • n > 0, por lo que llama xMethod(0)
              • n no > 0, por lo que vuelve sin hacer nada
            • Imprime "1"
          • Imprime "2"
        • Imprime "3"
      • Imprime "4"
    • Imprime "5"
    • Listo.
2
Erwin Bolwidt 25 feb. 2018 a las 07:59

Es muy simple en realidad.

Si llamamos a alguna función dentro de otra función, el control vuelve a la misma función una vez que la función llamada completa su ejecución.

En su caso como n == 0, la función llamada devuelve el control a la función de llamada, por lo tanto, imprime 1,2,3,4,5.

1
learner8269 25 feb. 2018 a las 08:01