Question

我通过在互联网上引用一些代码使用递归调用来编写fizzbuzz代码。下面的代码工作正常但我无法完全理解执行此代码时会发生什么。

更具体地说，我无法理解为什么首先显示CascadeType.ALL。在1方法中，main()收到recurrence()，因此感觉100（结果为100）首先显示。

我在IntelliJ上调试断点在Buzz上，该方法首先被调用100次，其余的代码在之后执行。我想知道recurrence(i - 1)的结果存储在哪里。

recuurence

Answer 1

您致电recurrence(100);
因recurrence(99);

100>1

因recurrence(98);

99>1

...
调用recurrence(1);，因为2>1 - ＆gt;转到else并打印1
然后进行所有其他打印

尝试使用更简单的代码来理解，该代码将打印1 2 3 4 5 6 7 8 9 10：

public static void main(String[] args) {
    recurrence(10);
}

private static void recurrence(int i) {
    if (i > 1) {
        recurrence(i - 1);
    }       
    System.out.println(String.valueOf(i));
}

>recurrence(10) 
  -> recurrence(9) 
    -> recurrence(8) 
      -> recurrence(7) 
        -> recurrence(6)
          -> recurrence(5)
            -> recurrence(4)
              -> recurrence(3)
                -> recurrence(2) 
                  -> recurrence(1) 
                  -> print(1)
                -> print(2)
              -> print(3)
            -> print(4)
          -> print(5) 
        -> print(6)
      -> print(7) 
    -> print(8)
  -> print(9)
-> print(10)

Answer 2

 if (i > 1) {
        recurrence(i - 1);
    }

此声明＆＃39;重新启动＆＃39;下面的方法和代码将不会执行，直到i＆gt; 1返回false（当i = 1时首先发生）。

关于存储结果的位置：您的方法的返回类型为void，这意味着没有结果。如果您正在考虑输出，我希望您现在明白它为什么不打印。

Answer 3

我无法理解为什么首先显示1。在main（）方法中，

因为第一次使用100调用使得此条件语句的递归调用循环为true：

if (i > 1) {
    recurrence(i - 1);
}

recurrence(100)，recurrence(99)，recurrence(98)，......直到recurrence(1)。在recurrence(1)的递归调用（i=1）中，事情是不同的，因为评估为true的单个条件语句是：

else
     System.out.println(String.valueOf(i));

首先打印1。

我理解为什么首先打印1。 1是复发的结果（1），但努力了解其他结果的来源。一世试着想一想。

下一个输出与当前堆叠调用的“unstack”有关。

调用的“取消堆叠”按照它们的相反顺序执行。所以你从最后一次调用到第一次调用都没有堆栈。

recurrence(100)，recurrence(99)，recurrence(98)，...， recurrence(2)，recurrence(1)被调用并堆叠并且从recurrence(1)，recurrence(2)，...完成拆散， recurrence(100)。

为了简化递归调用的工作原理，请记住方法调用是堆叠的（递归与否），堆栈是先进先出的结构。

所以回到解释，recurrence(1)到达这个陈述：

System.out.println(String.valueOf(i));

该方法返回，JVM继续前一个堆栈调用：

recurrence(2)执行以下语句（之前的语句已被调用）：

    if (i % 15 == 0) {
        System.out.println("FizzBuzz");
    } else if (i % 5 == 0) {
        System.out.println("Buzz");
    } else if (i % 3 == 0) {
        System.out.println("Fizz");
    } else
        System.out.println(String.valueOf(i));

与recurrence(1)类似，评估为true的单个条件语句为：

else
     System.out.println(String.valueOf(i));

所以打印2。

继续为当前堆叠的调用[{1}}，recurrence(3)应用相同的逻辑，直到recurrence(4)并且所有内容都应该清除。

Answer 4

如果你的功能开始，你就得到了

if (i > 1) {
            recurrence(i - 1);
        }

在这个地方＆＃34;下一级递归＆＃34;被调用（也就是说，在每个级别，你做的第一件事是调用另一个递归函数），当你到达最后一级（第100级 - ＆gt; i = 1）时，你可以得到代码

if (i % 15 == 0 ) {
            System.out.println("FizzBuzz");
        } else if (i % 5 == 0) {
            System.out.println("Buzz");
        } else if (i % 3 == 0) {
            System.out.println("Fizz");
        } else
            System.out.println(String.valueOf(i));
    }

在完成代码后，第100级（i = 1）结束，然后是第99级，第98级的时间，完成该功能的最后一名是第1级（i = 100）。

尝试在互联网上观看一些视频（递归如何工作），这将在演示文稿中进行解释，这将更容易理解。

如何递归调用工作

4 个答案: