[英]Stack overflow exception with 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));
}
您正在遇到df(n * df(n - 1));
的无限循环df(n * df(n - 1));
n * df(n-1)
将计算阶乘,并且您无意中将答案反馈到递归方法中,从而使它永远存在
更改
return df(n * df(n - 1));
至
return n * df(n - 1);
而且您应该获得阶乘的正确结果
一旦有了这种有效的递归阶乘方法,只需使用df(df(3))
轻松创建双重阶乘
我认为您应该在阶乘的帮助下使用相互递归。
一般的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));
}
我们可以做的:
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
>
首先,定义您的阶乘函数:
通过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);
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.