递归和使用for循环之间的区别？

Question

我可以使用递归或 for 循环计算阶乘，如下所示？

递归阶乘

int recursiveFactorial(int n){
    if(n<0)
        return;
    if(n==0 || n==1)
        return 1;
    else
        return n*recursiveFactorial(n-1);
}

并使用for循环

int forFacotrial(int n){
    if(n<0)
        return;
    if(n==0 || n==1)
        return 1;
    else{
       int fact=1;
       for(int i=2;i<=n;i++)
       {
             fact=fact*i;
       }
       return fact;
    }
}

两者在性能方面有什么区别？还有什么区别？

Answer 1

您将在递归版本中付出代价，因为除了调用的开销之外，您还将反复将

n

的值与

<0

、

==0

和

==1

进行比较，这在循环版本中是不必要的.

稍微高效的递归版本可能是：

int F(int n)
return n < 3 ? n : n * F(n-1)

拨打自

int G(int n)
return n < 2 ? 1 : F(n)

Answer 2

性能明智的循环更快、更安全。当您调用递归方法时，它始终作为方法调用执行。因此它在堆栈上分配内存。如果无限地调用递归方法，可能会导致堆栈溢出异常。当您使用循环时，内存分配发生在堆中，因为它的性能良好且更安全。

Answer 3

递归和循环之间的主要区别：

-Loop repeat it self ，但它有只有一个阶段：上升阶段或调用时的执行（当函数被调用时）。

-递归重复它自己，但它有两个阶段而不是一个：上升阶段和下降阶段或在调用时间执行和在返回时间执行。

我所说的上升阶段和下降阶段：

上升阶段：

• 代码执行（控制器）会转到下一条指令，下一条指令.....等..（-> 在调用时执行）

下降阶段：

• 就是代码执行（Controller）会因为调用阶段而返回到他们没有执行的指令。 (返回时间执行)

示例：

 void example(int n) {
     if(n>0){
      1.//Instruction during the calling time 
      2.//Instruction during the calling time
      3. example(n-1) 
      4. //Instruction executed when it will finish the Ascending phase  (Returning phase) 
      
     }
       }
       
       //Output expected  for n =3 : 3,2,1  printing is done at calling time
    
      /*      fun(3)
              /       \
              3        fun(2)
              /        \
              2        fun(1)
             /           \
             1           func(0)
             |                |
           calling pahse     - returning phase\
      */
       void func(int n){
       if(n>0){
        print(n)  //Instruction during the calling time 
        func(n-1)
                  // Intruction during the returning time (there is nothing so it                     will do nothing more when it will return back )
       }
       }
      //Output expected for n=3 : 1,2,3 printing is done at returning time
      /*      fun(3)
              /       \
              func(2)  -      3
              /        \
             func(1)    -     2
             /           \
             func(0)     -    1
             |
          - calling phase   returning phase  
      */
       void func(int n){
       if(n>0){
       func(n-1) //Instruction during the calling time
       print(n) //Instruction during the returning time 
       }
       
       }