Java - 理解递归

Question

有人可以向我解释为什么打印出来1 2 3 4 5？我想它会打印出4 3 2 1 0，但我的书和日食都说我错了。

public class whatever { 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     xMethod(5); 

    } 

    public static void xMethod(int n){ 
     if (n>0){ 
      xMethod(n-1); 
      System.out.print(n + " "); 
     } 
    } 


} 

Answer 1

这是很简单，这些都是

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

所以你看到的来电印刷品是1,2,3,4,5

Answer 2

这是正确的代码

System.out.print(n + " "); 
xMethod(n-1); 

Answer 3

它首先调用自身递归只有当递归调用结束它打印。 所以，想想它称之为第一完成 - 这是当n = 0 则n = 1等

这是一个堆栈，从堆栈中取（递归调用后）后打印，这样的顺序颠倒。 如果在放入堆叠前打印，则订单将被保留。

Answer 4

System.out.print(n + " "); 
xMethod(n-1); 

它将打印5 4 3 2 1.因为它会首先打印，然后调用xMethod。

对你来说

xMethod(n-1); 
System.out.print(n + " "); 

这将达到终止条件，那么POP操作并打印。所以1 2 3 4 5

Answer 5

此 xMethod第（n-1）; System.out.print（n +“”）;

应该是：

 System.out.print(n + " "); 
     xMethod(n-1); 

Answer 6

xMethod被称为直到n是0。该堆栈将是xMethod(5)->xMethod(4)->xMethod(3)->xMethod(2)->xMethod(1)->xMethod(0)。当它完成xMethod(0)时，它将弹出到xMethod(1)的下一行，打印1。然后重复此操作，直至退出xMethod(5)。

如果你去和扩大各xMethod因为它是所谓的代码看起来是这样的：

{ 
    nA = 5 // What n was set at first 
    if (nA>0){ 
     { 
      // Instead of xMethod(n-1), 
      // we're setting nB to nA - 1 and 
      // running through it again. 
      nB = nA - 1 // nB is 4 

      if (nB>0){ 
       { 
        nC = nB - 1 // nC is 3 
        if (nC>0){ 
         { 
          nD = nC - 1 // nD is 2 
          if (nD>0){ 
           { 
            nE = nD - 1 // nE is 1 
            if (nE>0){ 
             { 
              nF = nE - 1 // nF is 0. 
              if (nF>0){ 
               // This will never execute b/c nF is 0. 
              } 
             } 
             System.out.print(nE + " "); // prints 1 
            } 
           } 
           System.out.print(nD + " "); // prints 2 
          } 
         } 
         System.out.print(nC + " "); // prints 3 
        } 
       } 
       System.out.print(nB + " "); //prints 4 
      } 
     } 
     System.out.print(nA + " "); //prints 5 
    } 
} 

Answer 7

1 public static void xMethod(int n){ 
    2 if (n>0){ //the base condition 
    3   xMethod(n-1); //function is again called with one value less than previous 
    4   System.out.print(n + " "); //now print 
    5  } 
    6 } 

现在看线＃3，由于没有打印b再次调用该功能，因此从＃3行开始，呼叫再次到达＃1行。这意味着n是5，但是新的呼叫需要n = 4，并且它继续前进，直到线2指示n现在小于0.

当条件＃2失败时，它到达第＃ 5，然后是第6行，这意味着函数已经结束执行，此时n = 1。

现在应该在哪里返回呼叫？在最后一个函数被调用的第＃3行，它将从执行第4行的堆栈弹出，该行打印n的值，即1 2 3 4 5.

Answer 8

这是调用堆栈的结果。以下是n = 5致电后的样子。由于此调用链的底部实际上是堆栈的顶部，所以将您的头旋转180度。

• xMethod（5）
  • xMethod（4）
    • xMethod（3）
      • xMethod（2）
        • xMethod（1）
          • xMethod（0）

在递归调用，你有两个案例 - 基本情况和递归情况。这里的基本情况是n == 0，并且不会发生进一步的递归。

现在，当我们开始从这些调用回来时会发生什么？也就是发生了什么后的递归步骤？我们开始做System.out.print()。由于存在防止递归和当n == 0打印时的情况，所以我们既不递归也不打印。

所以，你得到1 2 3 4 5作为输出的原因是由于电话正在从堆栈中弹出的方式。

Answer 9

为了解释递归是如何工作的，让我们来看看阶乘计算的样本：

int factorial(int i) { 
    if (i == 0) { 
     return 1; 
    } 
    return i * factorial(i - 1); 
} 

例如，让我们的5因素值：

int result = factorial(5); 

记住退出值：

if (i == 0) { 
    return 1; 
} 

并返回值：

i * factorial(i - 1) 

只要看看迭代（根据返回值）：

5*factorial(4) -> 4*factorial(3) -> 3*factorial(2) -> 2*factorial(1) -> 1*factorial(0) 

事实上，它是：

5*(4*(3*(2*(1*factorial(0))))) 

原因factorial(4) == 4*factorial(3), factorial(3) == 3*factorial(2)等

最后一次迭代是factorial(0)，等于1（查看退出值）。

在结果：

5*(4*(3*(2*(1*1)))) = 120