Question

好的，这个程序的输出是

hello3
hello2
hello1

0
1
2

我需要在mymethod（ - counter）之后进行解释，为什么输出为0,1,2而不是3,2,1（PS int计数器的值为＆＃39; 3＆＃39; ）

public void mymethod(int counter){
    if(counter==0)
        System.out.println("");
    else{
        System.out.println("hello" + counter);
        mymethod(--counter);
        System.out.println(" " +counter);
    }

}

`

Answer 1

在递归期间发生的事情是，每次循环时，它会调用自身，参数减1，直到达到0.所以你有

import React from 'react'; const SomeComponent = ({ message }) => ( <div>{message}</div> ); SomeComponent.propTypes = {}; export default SomeComponent;调用mymethod(3)
这会调用mymethod(2)
这会调用mymethod(1)

现在到此为止，mymethod(0)位于堆栈的顶部。当递归被解开时，方法以相反的顺序完成，因此mymethod(1)先完成，然后mymethod(0)完成，最后mymethod(1)完成。

把它想象成一堆不同大小的盘子：当你把盘子堆起来时，你把它们从最大到最小;当你再把它们拿走时，你会把它们从最小到最大。

Answer 2

由于你得到hello3作为第一个输出，你可能在第一次调用myMethod（）时传入3作为参数：

//Imagine invoking myMethod() from the main..
public static void main(String[] args){
    myMethod(3);

}

调用 myMethod（3）会导致以下情况：

public void mymethod(3){
    if(counter==0)
        System.out.println("");
    else{                                       // <=== came into else block
        System.out.println("hello" + counter);  // <=== print "hello3"
        mymethod(--counter);                    // <=== invoke myMethod(2)
        System.out.println(" " +counter);
    }
}

调用 myMethod（2）会导致以下情况：

public void mymethod(2){
    if(counter==0)
        System.out.println("");
    else{                                       // <=== came into else block
        System.out.println("hello" + counter);  // <=== print "hello2"
        mymethod(--counter);                    // <=== invoke myMethod(1)
        System.out.println(" " +counter);
    }
}

调用 myMethod（1）会导致以下情况：

public void mymethod(1){
    if(counter==0)
        System.out.println("");
    else{                                       // <=== came into else block
        System.out.println("hello" + counter);  // <=== print "hello1"
        mymethod(--counter);                    // <=== invoke myMethod(0)
        System.out.println(" " +counter);
    }
}

调用 myMethod（0）会导致以下情况：

public void mymethod(0){
    if(counter==0)                              // <=== if-condition is true
        System.out.println("");                 // <=== print newline
    else{                                       
        System.out.println("hello" + counter);  
        mymethod(--counter);                    
        System.out.println(" " +counter);
    }
} // <=== exit method (goes back to last point where this myMethod(0) was callled)

从 myMethod（1） 继续：

public void mymethod(1){
    if(counter==0)
        System.out.println("");
    else{                                       
        System.out.println("hello" + counter);  
        mymethod(--counter);                    // <=== this point invoked myMethod(0)
        System.out.println(" " +counter);       // <=== continue from here (print " " + 0)
    }
} // <=== exit method (goes back to last point where this myMethod(1) was called

从 myMethod（2） 继续：

public void mymethod(2){
    if(counter==0)
        System.out.println("");
    else{                                       
        System.out.println("hello" + counter);  
        mymethod(--counter);                    // <=== this point invoked myMethod(1)
        System.out.println(" " +counter);       // <=== continue from here (print " " + 1)
    }
} // <=== exit method (goes back to last point where this myMethod(2) was called

从 myMethod（3） 继续：

public void mymethod(3){
    if(counter==0)
        System.out.println("");
    else{                                       
        System.out.println("hello" + counter);  
        mymethod(--counter);                    // <=== this point invoked myMethod(2)
        System.out.println(" " +counter);       // <=== continue from here (print " " + 2)
    }
} // <=== exit method (goes back to last point where this myMethod(3) was called

返回main()。

public static void main(String[] args){
    myMethod(3);
    //<=== continue from this point
}

Answer 3

递归函数可视化很棘手。

将调用函数视为堆栈，并在其上面调用函数。当被调用函数最终终止并且不调用另一个函数时，程序返回到堆栈上的下一个函数，该函数结束然后返回堆栈上的下一个函数，等等。

所以，打印的行＆＃34;你好＆＃34;调用+ counter，然后函数调用mymethod(--counter)。整个过程（降至mymethod(0)并返回）必须在第二个打印语句之前发生。

因此，您的程序打印hello3，hello2和hello1，将mymethod(3)，mymethod(2)和mymethod(1)放在堆栈上。它到达mymethod(0)，打印一个空字符串，然后按顺序返回mymethod(1)，mymethod(2)和mymethod(3)。在每种情况下，它都会打印--counter，这比参数中的计数器少一个。有意义吗？

需要帮助理解给定程序中的递归

3 个答案: