避免StackOverflowException 的最佳方法是不使用堆栈。
让我们摆脱否定的情况，因为当我们用uint 调用时它是没有意义的。或者，如果我们在考虑其他可能性之前将否定测试作为方法中的第一件事，那么下面的内容也将起作用：
首先，我们需要一艘更大的船：
public static BigInteger Ackermann(BigInteger m, BigInteger n)
{
if (m == 0)
return n+1;
if (n == 0)
return Ackermann(m - 1, 1);
else
return Ackermann(m - 1, Ackermann(m, n - 1));
}
现在成功至少在数学上是可能的。现在，n == 0 案例是一个足够简单的尾调用。让我们手动消除它。我们将使用goto，因为它是临时的，所以我们不必担心 velociraptors 或 Dijkstra：
public static BigInteger Ackermann(BigInteger m, BigInteger n)
{
restart:
if (m == 0)
return n+1;
if (n == 0)
{
m--;
n = 1;
goto restart;
}
else
return Ackermann(m - 1, Ackermann(m, n - 1));
}
这已经需要更长的时间来炸掉堆栈，但是炸掉它，它会的。不过看看这个表格，请注意m 永远不会由递归调用的返回设置，而n 有时是。
扩展这个，我们可以把它变成一个迭代形式，同时只需要处理跟踪m的先前值，并且我们将以递归形式返回，我们在迭代形式中分配给n。一旦我们用完等待处理的ms，我们就返回n的当前值：
public static BigInteger Ackermann(BigInteger m, BigInteger n)
{
Stack<BigInteger> stack = new Stack<BigInteger>();
stack.Push(m);
while(stack.Count != 0)
{
m = stack.Pop();
if(m == 0)
n = n + 1;
else if(n == 0)
{
stack.Push(m - 1);
n = 1;
}
else
{
stack.Push(m - 1);
stack.Push(m);
--n;
}
}
return n;
}
至此，我们已经回答了 OP 的问题。这将需要很长时间才能运行，但它会返回尝试过的值（m = 4，n = 2）。它永远不会抛出StackOverflowException，尽管它最终会在m 和n 的某些值之上耗尽内存。
作为进一步的优化，我们可以跳过向堆栈添加值，只是在之后立即弹出它：
public static BigInteger Ackermann(BigInteger m, BigInteger n)
{
Stack<BigInteger> stack = new Stack<BigInteger>();
stack.Push(m);
while(stack.Count != 0)
{
m = stack.Pop();
skipStack:
if(m == 0)
n = n + 1;
else if(n == 0)
{
--m;
n = 1;
goto skipStack;
}
else
{
stack.Push(m - 1);
--n;
goto skipStack;
}
}
return n;
}
这对我们的堆栈没有帮助，对堆也没有任何意义，但考虑到这个东西对大值的循环次数，我们可以剃掉的每一点都是值得的。
在保持优化的同时消除 goto 留给读者练习 :)
顺便说一句，我对这个测试太不耐烦了，所以我做了一个作弊表格，当 m 小于 3 时，它使用了 Ackerman 函数的已知属性：
public static BigInteger Ackermann(BigInteger m, BigInteger n)
{
Stack<BigInteger> stack = new Stack<BigInteger>();
stack.Push(m);
while(stack.Count != 0)
{
m = stack.Pop();
skipStack:
if(m == 0)
n = n + 1;
else if(m == 1)
n = n + 2;
else if(m == 2)
n = n * 2 + 3;
else if(n == 0)
{
--m;
n = 1;
goto skipStack;
}
else
{
stack.Push(m - 1);
--n;
goto skipStack;
}
}
return n;
}
使用这个版本，我可以在一秒多后得到true 和Ackermann(4, 2) == BigInteger.Pow(2, 65536) - 3 的结果（单声道，发布版本，在Core i7 上运行）。鉴于非作弊版本在返回 m 此类值的正确结果方面是一致的，我将此作为前一版本正确性的合理证据，但我将让它运行并查看。
编辑：当然，我并不真的期望以前的版本会在任何合理的时间范围内返回，但我想我还是让它继续运行，看看它的内存使用情况如何。 6 小时后，它的大小正好低于 40MiB。我很高兴虽然显然不切实际，但如果在真机上有足够的时间，它确实会返回。
编辑：显然有人认为Stack<T> 达到其 2³¹ 项的内部限制也算作一种“堆栈溢出”。如果必须，我们也可以处理：
public class OverflowlessStack <T>
{
internal sealed class SinglyLinkedNode
{
//Larger the better, but we want to be low enough
//to demonstrate the case where we overflow a node
//and hence create another.
private const int ArraySize = 2048;
T [] _array;
int _size;
public SinglyLinkedNode Next;
public SinglyLinkedNode()
{
_array = new T[ArraySize];
}
public bool IsEmpty{ get{return _size == 0;} }
public SinglyLinkedNode Push(T item)
{
if(_size == ArraySize - 1)
{
SinglyLinkedNode n = new SinglyLinkedNode();
n.Next = this;
n.Push(item);
return n;
}
_array [_size++] = item;
return this;
}
public T Pop()
{
return _array[--_size];
}
}
private SinglyLinkedNode _head = new SinglyLinkedNode();
public T Pop ()
{
T ret = _head.Pop();
if(_head.IsEmpty && _head.Next != null)
_head = _head.Next;
return ret;
}
public void Push (T item)
{
_head = _head.Push(item);
}
public bool IsEmpty
{
get { return _head.Next == null && _head.IsEmpty; }
}
}
public static BigInteger Ackermann(BigInteger m, BigInteger n)
{
var stack = new OverflowlessStack<BigInteger>();
stack.Push(m);
while(!stack.IsEmpty)
{
m = stack.Pop();
skipStack:
if(m == 0)
n = n + 1;
else if(m == 1)
n = n + 2;
else if(m == 2)
n = n * 2 + 3;
else if(n == 0)
{
--m;
n = 1;
goto skipStack;
}
else
{
stack.Push(m - 1);
--n;
goto skipStack;
}
}
return n;
}
再次调用Ackermann(4, 2) 返回：
这是正确的结果。使用的堆栈结构永远不会抛出，因此唯一剩下的限制是堆（当然还有时间，如果输入足够大，您将不得不使用“宇宙寿命”作为衡量单位......）。
由于它的使用方式类似于图灵机的磁带，我们想起了任何可计算函数都可以在足够大小的图灵机上计算的论点。