循环和堆栈的递归函数

Question

众所周知，所有递归函数都可以只使用一个循环和一个堆栈来编写。虽然这种转换可以被批评为丑陋或可读性差，但它的主要用途显然是避免破坏堆。

有很自然的方法可以将简单的递归函数转换为循环。例如，使用累加器进行简单的尾递归消除。到目前为止，我还没有看到这个问题的明确答案。

至少对我来说，有时将这样的递归函数转换为循环似乎是黑魔法，提供了一个堆栈。例如，考虑为

编写一个非递归版本

f(n) = n,                    if n <= 1
f(n) = f(n-1) + f(n-2) + 1,  if n > 1

这个问题的核心是：

• 是否有一种清晰的通用方法可以将递归函数转换为循环+堆栈？

Answer 1

可行性（100%）：

从here，我们知道任何递归函数都可以转换为迭代（进入循环），但您需要自己使用堆栈来保持状态。

---

如何做到这一点（一般）：

您可以查看文章 How to replace recursive functions using stack and while-loop to avoid the stack-overflow，其中提供了有关如何将递归函数转换为堆栈和 while 循环的示例和步骤（10 个步骤/规则）。实例见下节。

---

示例：

以下面的递归函数为例：

// Recursive Function "First rule" example
int SomeFunc(int n, int &retIdx)
{
    ...
        if(n>0)
        {
            int test = SomeFunc(n-1, retIdx);
            test--;
            ...
                return test;
        }
        ...
            return 0;
} 

应用文中介绍的10条规则/步骤后（详情见cmets），你会得到：

// Conversion to Iterative Function
int SomeFuncLoop(int n, int &retIdx)
{
    // (First rule)
    struct SnapShotStruct {
        int n;        // - parameter input
        int test;     // - local variable that will be used 
        //     after returning from the function call
        // - retIdx can be ignored since it is a reference.
        int stage;    // - Since there is process needed to be done 
        //     after recursive call. (Sixth rule)
    };
    // (Second rule)
    int retVal = 0;  // initialize with default returning value
    // (Third rule)
    stack<SnapShotStruct> snapshotStack;
    // (Fourth rule)
    SnapShotStruct currentSnapshot;
    currentSnapshot.n= n;          // set the value as parameter value
    currentSnapshot.test=0;        // set the value as default value
    currentSnapshot.stage=0;       // set the value as initial stage
    snapshotStack.push(currentSnapshot);
    // (Fifth rule)
    while(!snapshotStack.empty())
    {
        currentSnapshot=snapshotStack.top();
        snapshotStack.pop();
        // (Sixth rule)
        switch( currentSnapshot.stage)
        {
        case 0:
            // (Seventh rule)
            if( currentSnapshot.n>0 )
            {
                // (Tenth rule)
                currentSnapshot.stage = 1;            // - current snapshot need to process after
                //     returning from the recursive call
                snapshotStack.push(currentSnapshot);  // - this MUST pushed into stack before 
                //     new snapshot!
                // Create a new snapshot for calling itself
                SnapShotStruct newSnapshot;
                newSnapshot.n= currentSnapshot.n-1;   // - give parameter as parameter given
                //     when calling itself
                //     ( SomeFunc(n-1, retIdx) )
                newSnapshot.test=0;                   // - set the value as initial value
                newSnapshot.stage=0;                  // - since it will start from the 
                //     beginning of the function, 
                //     give the initial stage
                snapshotStack.push(newSnapshot);
                continue;
            }
            ...
                // (Eighth rule)
                retVal = 0 ;

            // (Ninth rule)
            continue;
            break; 
        case 1: 
            // (Seventh rule)
            currentSnapshot.test = retVal;
            currentSnapshot.test--;
            ...
                // (Eighth rule)
                retVal = currentSnapshot.test;
            // (Ninth rule)
            continue;
            break;
        }
    }
    // (Second rule)
    return retVal;
} 

---

顺便说一句，上面的文章是CodeProject的Prize winner in Competition <Best C++ article of July 2012>，所以应该是可信的。 :)

Answer 2

是的，但解决方案不会比递归解决方案好多少，除了可能会减少堆栈溢出的机会。

通过查看与斐波那契数列类似的序列，除了 n = (0,1) 之外的每一轮的结果都加 1，您会看到一个模式。

0 1 2 4 7 12 20 
    \  \___ ...\____
    0+1+1  1+2+1   7+12+1

由于整个生成依赖于前两个数字，因此您可以在循环中使用两个变量来表示该数字，而您根本不需要堆栈。

//intentional generic algol dialect
int modfib (int n)
{
    if( n <= 1 )
      return n;
    n = n - 2;
    int a=2;
    int b=4;
    int tmp;
    while( n-- > 0 )
    {
        tmp=a;
        a=b;
        b = tmp + b +1;
    }
    return a;
}

在编译器知道这样做之前，我们仍然需要人工来优化代码。