java递归栈_Java中的深度递归会导致堆栈溢出？

增加堆栈大小只会用作临时绷带。正如其他人指出的那样，您真正想要的是消除尾部调用，而Java出于各种原因没有此功能。但是，您可以根据需要作弊。

手中有红色药丸吗？好的，请这样。

您可以通过多种方法将堆栈交换为堆。例如，不是在函数内进行递归调用，而是让它返回在评估时进行调用的惰性数据结构。然后，您可以使用Java的for-construct解散“堆栈”。我将举一个例子。考虑以下Haskell代码：

map :: (a -> b) -> [a] -> [b]

map _ [] = []

map f (x:xs) = (f x) : map f xs

请注意，此函数永远不会评估列表的末尾。因此，该函数实际上不需要进行递归调用。实际上，在Haskell中，它会为尾巴返回一个thunk，如果有需要的话会调用它。我们可以在Java中做同样的事情(这使用了Functional Java中的类)：

public Stream map(final F f, final Stream as)

{return as.isEmpty()

? nil()

: cons(f.f(as.head()), new P1>()

{public Stream _1()

{return map(f, as.tail);}});}

请注意，它Stream由一个type A的值和一个type 的值组成P1，类似于thunk，当调用_1()时，thunk返回流的其余部分。虽然看起来确实像递归，但不会进行对map的递归调用，而是成为Stream数据结构的一部分。

然后可以使用常规的for-construct进行解包。

for (Stream b = bs; b.isNotEmpty(); b = b.tail()._1())

{System.out.println(b.head());}

这是另一个例子，因为您在谈论欧拉计划。该程序使用相互递归函数，即使对于数百万次调用也不会破坏堆栈：

import fj.*; import fj.data.Natural;

import static fj.data.Enumerator.naturalEnumerator;

import static fj.data.Natural.*; import static fj.pre.Ord.naturalOrd;

import fj.data.Stream; import fj.data.vector.V2;

import static fj.data.Stream.*; import static fj.pre.Show.*;

public class Primes

{public static Stream primes()

{return cons(natural(2).some(), new P1>()

{public Stream _1()

{return forever(naturalEnumerator, natural(3).some(), 2)

.filter(new F()

{public Boolean f(final Natural n)

{return primeFactors(n).length() == 1;}});}});}

public static Stream primeFactors(final Natural n)

{return factor(n, natural(2).some(), primes().tail());}

public static Stream factor(final Natural n, final Natural p,

final P1> ps)

{for (Stream ns = cons(p, ps); true; ns = ns.tail()._1())

{final Natural h = ns.head();

final P1> t = ns.tail();

if (naturalOrd.isGreaterThan(h.multiply(h), n))

return single(n);

else {final V2 dm = n.divmod(h);

if (naturalOrd.eq(dm._2(), ZERO))

return cons(h, new P1>()

{public Stream _1()

{return factor(dm._1(), h, t);}});}}}

public static void main(final String[] a)

{streamShow(naturalShow).println(primes().takeWhile

(naturalOrd.isLessThan(natural(Long.valueOf(a[0])).some())));}}

将堆栈交换为堆的另一件事是使用多个线程。这个想法是，您不是创建递归调用，而是创建一个进行调用的thunk，将此thunk传递给新线程，并让当前线程退出该函数。这就是Stackless Python之类的东西背后的想法。

以下是Java中的示例。抱歉，如果没有这些import static条款，看起来有点不透明：

public static Promise foldRight(final Strategy s,

final F> f,

final B b,

final List as)

{return as.isEmpty()

? promise(s, P.p(b))

: liftM2(f).f

(promise(s, P.p(as.head()))).f

(join(s, new P1>>()

{public Promise _1()

{return foldRight(s, f, b, as.tail());}}));}

Strategy s由线程池支持，该promise函数将一个thunk交给线程池，返回a Promise，这很像java.util.concurrent.Future，只是更好。看这里。关键是上面的方法在O(1)堆栈中向右折叠了一个右递归数据结构，这通常需要消除尾调用。因此，我们已经有效地实现了TCE，以换取一些复杂性。您可以按以下方式调用此函数：

Strategy s = Strategy.simpleThreadStrategy();

int x = foldRight(s, Integers.add, List.nil(), range(1, 10000)).claim();

System.out.println(x); // 49995000

注意，后一种技术对于非线性递归非常有效。也就是说，即使没有尾调用的算法，它也可以在恒定堆栈中运行。

您可以做的另一件事是采用一种称为蹦床的技术。蹦床是一种计算过程，可简化为数据结构，可以逐步执行。该功能的Java库包括Trampoline我写的数据类型，从而有效地让你把任何函数调用到尾调用。作为一个示例，下面是一个经过抛光处理的游标foldRightC，它以恒定的堆栈向右折叠：

public final Trampoline foldRightC(final F2 f, final B b)

{return Trampoline.suspend(new P1>()

{public Trampoline _1()

{return isEmpty()

? Trampoline.pure(b)

: tail().foldRightC(f, b).map(f.f(head()));}});}

这与使用多个线程的原理相同，不同之处在于，我们不是在自己的线程中调用每个步骤，而是在堆上构造每个步骤，就像使用a一样Stream，然后使用在一个循环中运行所有步骤Trampoline.run。