Optimization 递归到迭代转换

知道每个递归函数都可以转换为迭代版本。有人能帮我找到这个伪代码的迭代版本吗？我正在尝试优化代码，递归显然不是我要走的路

sub calc (a, b )
{
    total = 0;
    if(b <= 1) 
        return 1
    if( 2*a > CONST)
        for i IN (1..CONST)
            total += calc(i, b-1) ;
    else
        for j IN (2*a..CONST)
            total += calc(j, b-1) ;
    return total;
}
CONST = 100;
print calc (CONST,2000);

分项计算（a、b）
{
总数=0；
if（b常数）
对于i IN（1..CONST）
总+=计算值（i，b-1）；
其他的
对于j英寸（2*a..CONST）
总+=计算值（j，b-1）；
返回总数；
}
常数=100；
打印计算（CONST，2000）；

---

谢谢你的帮助

从递归到迭代的重构并不能解决性能问题。该算法从缓存中获益最大，其方式与斐波那契序列非常相似

在F#中编写一个简短的测试程序后，使用一些样本数据（

CONST=5

，

a=0..10

，

b=2..10

）：

• 原始程序耗时6.931秒
• 缓存的版本花费了0.049秒

解决方案是保留一个键为

tuple（a，b）

的字典，并在计算之前查找值。以下是缓存的算法：

dictionary = new Dictionary<tuple(int, int), int>();

sub calc (a, b )
{
    if (dictionary.Contains(tuple(a,b)))
        return dictionary[tuple(a,b)];
    else
    {
        total = 0;
        if(b <= 1) 
            return 1
        if( 2*a > CONST)
            for i IN (1..CONST)
                total += calc(i, b-1);
        else
            for j IN (2*a..CONST)
                total += calc(j, b-1);

        dictionary[tuple(a,b)] = total;
        return total;
    }
}

dictionary=newdictionary（）；
次级计算（a、b）
{
if（dictionary.Contains（元组（a，b）））
返回字典[元组（a，b）]；
其他的
{
总数=0；
if（b常数）
对于i IN（1..CONST）
总+=计算值（i，b-1）；
其他的
对于j英寸（2*a..CONST）
总+=计算值（j，b-1）；
字典[元组（a，b）]=总计；
返回总数；
}
}

编辑：为了确认不是我的测试的迭代性质导致了性能的提高，我用一组参数（

CONST=5

，

a=6

，

b=20

）再次尝试了它们

• 缓存的版本花费了0.034秒
• 原始版本仍在运行。。。（2分钟以上）

---

只有尾部递归算法可以转换为迭代算法。您提供的代码肯定不是尾部递归的，因此无法轻松转换为迭代形式

---

性能问题的解决方案是

什么是总计？它是在别处定义的还是应该在功能体内部初始化？在功能体中初始化谢谢。另外，您是否可以提供一些示例输入和输出？该算法看起来几乎不需要迭代或递归，只需要一个数学公式。示例输入常量=4 a=4和b=5最终答案应该是个好主意，但我认为它需要一些改进，因为我们从未为相同的a调用函数，b对缓存在这种情况下不会有多大帮助。@实际上，您经常为相同的a、b对调用该函数。