Question

我目前正在学习Java中的递归。我为练习做了一些代码。

public class Tester{
    public static void main(String[] args){
        rec(5);
    }
    public static void rec(int x){
        if(x<=0){
            return;
        }else{
            System.out.print(x+" ");
            rec(x-1);
        }
    }
}
// Output: 5 4 3 2 1

但如果我现在用System.out.print(x+" ");切换rec(x-1);，我会得到一个完全不同的输出，即相反：1 2 3 4 5

这怎么可能？我理解是这样的：

我们有整数5，我们会查看该方法。 if语句不适用，因此我们将5减少1，我们有x=4，我们重复该方法（未达到打印，因此没有打印任何内容）。如上所述，我们对x=4也这样做。如果声明不适用，我们会将4减少1并重复此方法。我们重复，直到我们有x=0。在这种情况下，我们返回，所以这是方法的结束。我根本不了解我们如何获得反向输出，我甚至不明白为什么我们有输出......？：■

Answer 1

试试这个：

public class Tester{
    public static void main(String[] args){
        rec(5);
    }
    public static void rec(int x){
        if(x<=0){
            return;
        }else{
            rec(x-1);
            System.out.print(x+" ");
        }
    }
}

原因是您首先需要达到转义条件（x == 0），然后与您的方法调用相比，以反向模式开始打印数字：

rec(5)
    rec(4)
        rec(3)
            rec(2)
                rec(1)
                    rec(0) // We stop here
                System.out.print('1 ')
            System.out.print('2 ')
        System.out.print('3 ')
    System.out.print('4 ')
System.out.print('5 ')

Answer 2

好的，让我们研究第一个案例

首先是print语句然后是递归调用：干运行：

x = 5  Prints 5 then calls rec(4)
x = 4  Prints 4 then calls rec(3)
x = 3  Prints 3 then calls rec(2)
x = 2  Prints 2 then calls rec(1)
x = 1  Prints 1 then calls rec(0)
x = 0  Base case reached, so method returns in the following sequence->
rec(1) -> rec(2) -> rec(3) -> rec(4) -> rec(5) ->main()

因为在这种情况下，在递归调用之后没有更多的语句要执行，所以没有发生任何事情并且该方法开始返回现在针对第二种情况：首先是递归调用然后是print语句干运行：

x = 5 as x is not less than equal to 0 goes to rec(4) but print statement is now pending execution. It wont happen until the recursive call returns
x = 4 as x is not less than equal to 0 goes to rec(3) but again print is on hold
x = 3 as x is not less than equal to 0 goes to rec(2) but still print is on hold
x = 2 as x is not less than equal to 0 goes to rec(1) but still print is on hold
x = 1 as x is not less than equal to 0 goes to rec(0) but still print is on hold
x = 0 as x is now 0, rec(0) returns to rec(1)

现在rec（1）有一个待处理的打印状态，现在执行时值为1 然后rec（2）有一个挂起的print语句，现在执行值为2 然后rec（3）有一个挂起的print语句，现在执行值为3 然后rec（4）有一个挂起的print语句，现在执行值为4 然后rec（5）有一个挂起的print语句，现在执行值为5 然后rec（5）返回main（）

因此在这种情况下，输出是1-> 2-> 3-> 4-> 5 在第一种情况下，它是5-> 4-> 3-> 2-> 1

希望这有助于您的理解： - ）

Answer 3

您获得的输出是正确的。

以下案例1：

...
System.out.print(x+" ");
rec(x-1);
...

正确的输出是：5 4 3 2 1

以及以下案例2：

...
rec(x-1);
System.out.print(x+" ");
...

正确的输出是：1 2 3 4 5

<强>说明：在递归函数中，每个调用都放在一个堆栈上（因此，以 last-in-first-out 顺序执行）。

在案例1中，rec(x)首先打印其参数的值，然后调用rec(x-1)，因此顺序恰好是x x-1 x-2 ...。以下是执行顺序：

rec(5)
    print 5
    rec(4)
        print 4
        rec(3)
            print 3
            rec(2)
                print 2
                rec(1)
                    print 1
                    rec(0)
                        rec(0) return
                    rec(1) return
                rec(2) return
            rec(3) return
         rec(4) return
     rec(5) return

在案例2中，rec(x)函数在打印其参数之前首先调用rec(x-1)。以下是案例2中的执行顺序：

rec(5)
    rec(4)
        rec(3)
            rec(2)
                rec(1)
                    rec(0)
                        rec(0) return
                    print 1
                    rec(1) return
                print 2
                rec(2) return
            print 3
            rec(3) return
         print 4
         rec(4) return
     print 5
     rec(5) return

我希望这有助于您了解上述两种情况下的输出。我还鼓励您阅读以下stackoverflow答案here，其中描述了递归函数如何更详细地工作。

递归问题 - 我不明白为什么我得到反向输出

3 个答案: