while循环内的递归，它是如何工作的？

Question

你能告诉我这段java代码是如何工作的吗？ :

public class Main {
    public static void main (String[] args)  {
        Strangemethod(5);
    }
    public static void Strangemethod(int len) {
        while(len > 1){
            System.out.println(len-1);
            Strangemethod(len - 1);
        }
}
}

我尝试调试它并一步步按照代码操作，但我不明白。

更新：抱歉，我没有提到我知道这段代码的结果，只是想知道执行的步骤。

Answer 1

这将打印 4 3 2 1 1 1 1 1 1...

并陷入循环，因为在 while 循环范围内没有任何内容修改 len 。第一个调用（len=5、4、然后 3）经历一个循环迭代，并等待 Strangemethod 返回。当len=2时，while循环调用strangemethod(1)，并且由于len不大于1，因此while循环结束并且该调用返回。但在最底层的剩余 whle 循环中 len 仍然是 2，因此它再次调用了 oddmethod(2)。又来了。又来了。

if() 比 while() 更合适。

Answer 2

如果我没记错的话，这不是导致无限循环吗？

一旦奇怪方法（1）返回，奇怪方法（2）将再次打印1，然后再次调用奇怪方法（1）。

您是否忘记在奇怪的方法调用后递减 len ？

Answer 3

编辑：抱歉，第一个回复没有
意识到这一点..它将导致无限
循环

这是一个简单的流程 -
例如 len =5

 public static void Strangemethod(5) {
            while(5 > 1){
                System.out.println(5-1);
                Strangemethod(5 - 1);
            }
public static void Strangemethod(4) {
            while(4 > 1){
                System.out.println(4-1);
                Strangemethod(4 - 1);
            }
public static void Strangemethod(3) {
            while(3 > 1){
                System.out.println(3-1);
                Strangemethod(3 - 1);
            }
    public static void Strangemethod(2) {
            while(2 > 1){
                System.out.println(2-1);
                Strangemethod(2 - 1);
            }
    public static void Strangemethod(1) {
            while(1 > 1){//goes back to original(above) call and then an infinite loop since len was never  decremented

            }

打印 4 3 2 1 1.....

Answer 4

我知道我已经迟到了将近 13 年，但是我在大学的一次测验中遇到了这个问题，我回答错了，而且我不明白为什么会出现这样的情况。所以我花了一些时间，我相信我可以用一种对每个人都有意义的方式来解释它。

Iteration #1. 方法调用中声明的 while 循环 oddMethod(5);

    public static void strangeMethod(5) {
        while (5> 1) {
            System.out.println(4);
            strangeMethod(4);
        }
    }

因为 5 大于 1，所以 while 块中的代码被执行，所以，现在我们可以在控制台中看到 print 语句，但这里真正重要的是你要注意，是我们没有运行第二个这个 while 循环的迭代，事实上，我们甚至没有完成第一次迭代，它中途暂停了，以便它可以执行奇怪方法（4）的递归调用，并且它永远没有机会完成

确保我们在同一页面上，您对“在调用 oddMethod(5); 中执行了多少次 while 循环迭代完成？”这个问题的回答应该甚至不是一次迭代。

但是，我们确实调用了 oddMethod(4);现在这是一个新的方法调用，其中的 while 循环将开始执行，因为满足其继续条件，4 大于 1，但是，就像之前的调用一样，它甚至不会完成一次迭代，并且会调用奇怪的方法（3）；

Iteration #1. 方法调用中声明的 while 循环 oddMethod(4);

    public static void strangeMethod(4) {
        while (4 > 1) {
            System.out.println(3);
            strangeMethod(3);
        }
    }

Iteration #1. 方法调用中声明的 while 循环 oddMethod(3);

    public static void strangeMethod(3) {
        while (3 > 1) {
            System.out.println(2);
            strangeMethod(2);
        }
    }

Iteration #1. 方法调用中声明的 while 循环 oddMethod(2);

    public static void strangeMethod(2) {
        while (2 > 1) {
            System.out.println(1);
            strangeMethod(1);
        }
    }

现在，调用 oddMethod(2);是不同的，因为它是唯一一次对 oddMethod() 实际上会迭代多次的调用。

您会看到，while 循环的继续条件是，如果 2 大于 1，这将始终为 true，就像之前的所有调用一样。这个方法的不同之处在于，strangeMethod(1); call 不会中断并暂停 while 循环，它会开始执行，看到没有满足继续条件 while (1 > 1)，并且由于在 oddMethod(1) 的调用中没有其他代码；为了让它执行，strangeMethod(1)；实际上会完成，允许我们从上次停下的地方继续，即完成 oddMethod(2) 的迭代#1；开始奇怪方法(2)的迭代#2；检查 while 循环的继续条件 (2>1) 是否仍然成立，执行 print 语句，执行 oddMethod(1)；调用将完成，并允许我们开始奇怪方法（2）的迭代#3；由于我们没有 len == 1 时的基本情况，所以 oddMethod(2);将无限期地迭代。

因此，调用了 oddMethod(2);其独特之处在于，其中要执行的所有代码实际上都会被执行，从而允许其中的 while 循环进行迭代。

Iteration #2. 方法调用中声明的 while 循环 oddMethod(2);

    public static void strangeMethod(2) {
        while (2 > 1) {
            System.out.println(1);
            strangeMethod(1); //Is now just some dead code 
        }
    }

Iteration #3. 方法调用中声明的 while 循环 oddMethod(2);

    public static void strangeMethod(2) {
        while (2 > 1) {
            System.out.println(1);
            strangeMethod(1); //Is now just some dead code 
        }
    }

现在，如果这仍然没有创造出啊哈！现在，请考虑执行以下操作，通过添加一个简单的 if 块来调整代码

    public static void strangeMethod(2) {
                if (len == 1) {
                        System.out.println(
                                "strangemethod(1) was executed and finished, 
                                The while loop within it did not run 
                                because its condition was not met
                                Thus, allowing us to move on to the second
                                Iteration of the while loop within 
                                strangeMethod(2);"
                        );
                }
        while (2 > 1) {
            System.out.println(1);
            strangeMethod(1);
        }
    }

或

    public static void strangeMethod(2) {
                if (len == 1) {
                    System.exit(0); // which will end all the previous 
                                    // method calls, unlike return; which will 
                                    // only end strangeMethod(1); but keep 
                                    // strangeMethod(2) still active and                                    
                                    // running
                }
        while (2 > 1) {
            System.out.println(1);
            strangeMethod(1);
        }
    }

对于任何认为我的答案有帮助的人，如果您愿意投票，我将不胜感激。< /强>

Answer 5

您没有说出您希望代码做什么。但是，值得注意的是，len 变量不会更改 Strangemethod 方法中的值 - 它可以被声明为 final。可能您想要做的是使用 --len; 递减它（相当于 len = len - 1;）。

Answer 6

尝试在 Strangemethod(len - 1); 之后添加 len--;。那么它不会让你陷入无限循环。或者，你可以这样做

System.out.println(--len);
Strangemethod(len);

Answer 7

这段代码将永远循环。

len - 1 的结果永远不会存储在 while 循环中，因此它无法退出，当 len = 2 时，它只会坐在那里输出 1。

在递归函数中使用 while 的情况并不常见。我通常希望在其位置看到一个 if ，这将为您提供输出：

4
3
2
1

如果您确实需要 while 那么我会像这样重写循环：

while(len > 1)
{
  len--;
  System.out.println(len);
  Strangemethod(len);
}

这将输出：

4
3
2
1
1
2
1
1
3
2
1
1
2
1
1

Answer 8

另外，我认为有人应该指出 len 永远不会递减，所以你会得到一个无限循环。我发现到目前为止只有 7 人提到过这一点。