Question

我正在练习递归，我不明白为什么这种方法似乎不起作用。有什么想法吗？

    public void fact()
    {
        fact(5);
    }

    public int fact(int n)
    {
        if(n == 1){
            return 1;
        }
        return n * (fact(n-1));
    }
}

由于

Answer 1

您的代码似乎有效，但您没有对返回的值执行任何操作，将方法调用fact或fact(5)置于System.out.println内并查看您获得的内容。

Answer 2

递归部分很好;你只是没有使用它被丢弃的return值。这是一个完整的Java因子代码应用程序，为了教育目的而略显激动：

public class Factorial {
    public static String fact(int n) {
        if(n == 1){
            return "1";
        }
        return n + " * " + (fact(n-1)); // what happens if you switch the order?
    }
    public static void main(String[] args) {
        System.out.println(fact(5));
        // prints "5 * 4 * 3 * 2 * 1"
    }
}

Answer 3

代码的简化版本：

public int fact(int n)
{
    if(n == 1){
        return 1;
    }
    return n * (fact(n-1));
}

可能只是：

public int fact(int n)
{
    return n == 1 ? 1 : n * fact(n - 1);
}

但是你的代码没有错，这只是另一种风格（如果你不习惯三元运算符保持它的方式）。在这些情况下，我更喜欢使用三元运算符（观察代码是无副作用的）。

Answer 4

工作正常。你没有把它分配给任何东西。这是一个可以证明它有效的测试。

@Test
public void testYourFactorialMethod() {
    assertEquals(120, fact(5));
}

Answer 5

public class Recursive {

    public static void main(String[] argss) {
        System.out.print(fac(3));
    }
    public static int fac(int n) {
        int value = 0;
        if (n == 0) {
            value = 1;
        } else {
            value = n * fac(n - 1);
        }
        return value;
    }
}
// out put 6

Answer 6

尝试这样的事情：（或者可以直接试试）

public class factorial {

    private static int factorial( int n ){
        if (n > 1)  {
            return n * (factorial(n-1));
        } else {
            return 1;
        }
    }

    public static void main(String[] args) {
        System.out.println(factorial(100));
    }
}

Answer 7

static int factorial(int x) {    
    int result;    
    if (x == 1) {    
        return 1;    
    }    
    // Call the same method with argument x-1    
    result = factorial(x – 1) * x;    
    return result;    
}

有关完整示例，请查看此

http://answersz.com/factorial-program-in-java-using-recursion/

Answer 8

用递归方法写斐波那契是完全错误的!!

这是一个古老的着名例子，说明好/坏Algorythm如何影响任何项目

如果你写Fibonatcci递归，计算120你需要36年才能得到结果!!!!!!

public static int Fibonacci(int x)
{  // bad fibonacci recursive code
if (x <= 1)
      return 1;
return Fibonacci(x - 1) + Fibonacci(x - 2);
}

在dot net 4.0中有一个新的类型名称BigInteger，您可以使用它来实现更好的功能

使用System; 使用System.Collections.Generic; 使用System.Numerics; //需要一个参考。到这个集会

namespace Fibonaci
{
 public class CFibonacci
 {
   public static int Fibonacci(int x)
   {
       if (x <= 1)
           return 1;
       return Fibonacci(x - 1) + Fibonacci(x - 2);
   }

   public static IEnumerable<BigInteger> BigFib(Int64 toNumber)
   {
       BigInteger previous = 0;
       BigInteger current = 1;

       for (Int64 y = 1; y <= toNumber; y++)
       {
           var auxiliar = current;
           current += previous;
           previous = auxiliar;
           yield return current;
       }
   }
 }
}

你可以像

一样使用它

using System;
using System.Linq;

namespace Fibonaci
{
 class Program
 {
   static void Main()
   {
       foreach (var i in CFibonacci.BigFib(10))
       {
           Console.WriteLine("{0}", i);
       }

       var num = 12000;
       var fib = CFibonacci.BigFib(num).Last();
       Console.WriteLine("fib({0})={1}", num, fib);

       Console.WriteLine("Press a key...");
       Console.ReadKey();
   }
 }
}

在这种情况下，您可以计算12000不到一秒钟。所以

使用递归方法并不总是一个好主意

从Vahid Nasiri blog whiche wrote in Persian

导入的上述代码

基本递归方法 - 阶乘

8 个答案: