递归

时间:2015-11-17 20:53:17

标签: java recursion

我正在尝试制作一个计算双因子的程序(例子 - n = 3,=>(3!)!= 6!= 720 )但我有一些递归底部的问题我有堆栈溢出异常。

public static long df(long n) {
    if (n == 1) {
        return 1;
    } else {
        return df(n * df(n - 1));
    }
}

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

4 个答案:

答案 0 :(得分:3)

您遇到了hg update -r $(hg id -i -r name repo2)

的无限循环

df(n * df(n - 1));将计算阶乘,并且您无意中将您的答案反馈回递归方法,导致它永远持续下去

更改

n * df(n-1)

return df(n * df(n - 1));

你应该得到因子的正确结果

一旦有了这种有效的递归因子方法,只需使用return n * df(n - 1);

就可以更轻松地创建双因子

答案 1 :(得分:1)

我认为你应该在factorial的帮助下使用相互递归。

一般的g因子函数可以构成阶乘g次:

public static long gf(long n, long g) {
    if (g == 1){
        return fact(n);
    }
    return fact(gf(n, g - 1));
}

特定的双因子可以是gf(n, 2)

public static long df(long n) {
    return gf(n, 2);
}

和阶乘辅助函数:

public static long fact(long n) {
    if (n == 1) {
        return 1;
    } else {
        return n * fact(n - 1);
    }
}

现在测试:

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

答案 2 :(得分:0)

我们可以做到:

public static long factorial(long n) {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

public static long twice_factorial(long n) {
    return factorial(factorial(n));
}

并且,如果需要,可以通过一些技巧将其转换为单个方法:

public static long twice_factorial(long n) {

    return new Object() {
        long factorial(long n) {
            return (n <= 1) ? 1 : n * factorial(n - 1);
        }

        long twice_factorial(long n) {
            return factorial(factorial(n));
        }
    }.twice_factorial(n);
}

但这是一个无用的函数,因为它仅对n <4有好处-一旦达到(4!)!,我们就超过了Java的long类型的限制:

(4!)! = 24! = 620,448,401,733,239,439,360,000
Java 'long' +max  = 9,223,372,036,854,755,807

如果您希望此函数有用,则可以改用浮动近似方程。但是,再次对近似值调用近似阶乘可能没有多大意义。您需要一个嵌套阶乘值本身的浮动近似方程。

或者,我们可以切换到BigInteger

import java.math.BigInteger;

public class Test {

    public static BigInteger factorial(BigInteger n) {
        return (n.compareTo(BigInteger.ONE) <= 0) ? n : n.multiply(factorial(n.subtract(BigInteger.ONE)));
    }

    public static BigInteger twice_factorial(BigInteger n) {
        return factorial(factorial(n));
    }

    public static void main(String[] args) {
        System.out.println(twice_factorial(new BigInteger(args[0])));
    }
}

用法

> java Test 4
620448401733239439360000
>

但这只能达到(7!)!在我们得到java.lang.StackOverflowError之前!如果想走得更远,我们需要转储递归并迭代计算阶乘:

public static BigInteger factorial(BigInteger n) {
    BigInteger result = BigInteger.ONE;

    while (n.compareTo(BigInteger.ONE) > 0) {
        result = result.multiply(n);

        n = n.subtract(BigInteger.ONE);
    }

    return result;
}

用法

> java Test 8
34343594927610057460299569794488787548168370492599954077788679570543951730
56532019908409885347136320062629610912426681208933917127972031183174941649
96595241192401936325236835841309623900814542199431592985678608274776672087
95121782091782285081003034058936009374494731880192149398389083772042074284
01934242037338152135699611399400041646418675870467025785609383107424869450
...
00000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000
> 

答案 3 :(得分:-2)

首先,定义你的阶乘函数:

通过Jupyter:

#include <iostream>
std::cout << "some output" << std::endl;

long fac(long n) {
    if( n == 1)
        return 1;
    else
        return n * fac((n-1));
}

定义你的功能后:

long double_fac(long n)
{
    long step_one = fac(n);
    return fac(step_one);
}

Factorielle-Algorythme