从汉诺塔问题谈递归转非递归的通法

Introduction

• 递归方法是我们经常使用的一种实现策略，只要思路清晰，实现起来就会非常简单。
• 然而，递归方法也是有一些缺点的，比如需要使用系统栈维护现场，资源及时间的开销都比非递归要大的多。而在acm竞赛中，也会有系统栈大小的限制，如果递归深度过深，很有可能爆栈。因此，有时非递归转递归还是很有必要的。
• 当然，我们都知道递归转非递归无非就是我们维护一个栈，模拟系统栈就好啦~然而，具体怎么模拟，不实际去做，我们是很难体会到其中的困难的。
• 在之前的面试中，学到了一种个人感觉非常简单实用的转换策略，可以说是一种通法，这里就想借着汉诺塔问题来分享一下~

汉诺塔

• 汉诺塔问题大家都比较熟悉吧，具体题意和思路我就不说了，放一个openjudge上百练的连接：

  http://bailian.openjudge.cn/practice/4147/

• 这里先给出递归的代码：

#include <bits/stdc++.h>
using namespace std;
void move(char a, char c, int n)
{
    cout << n<<":"<<a<<"->"<<c<<endl;
}
void dfs(char a, char b, char c, int n){

    if (n == 1){
        move(a, c, n);
        return;
    }
    dfs(a,c,b,n-1);
    move(a, c, n);
    dfs(b, a, c, n-1);
}

int main()
{
    char a,b,c;
    int n;
    cin>>n>>a>>b>>c;
    dfs(a,b,c,n);
    return 0;
}

• 这段递归代码非常简单，但是想要把它转换为非递归，却不是那么容易。当然也有一些方法是针对汉诺塔问题给出的非递归实现方法，但这不是我们关注的重点。我们希望通过模拟系统栈，给出一种通法。
• 通法思路非常简单：用一个栈维护函数名，参数信息，然后每次出栈的如果是递归调用的函数，我们就倒序把这个把递归函数的每行语句插入到栈中；出栈的如果是非递归的函数，我们就正序执行它就好了。
• 汉诺塔问题的非递归实现如下

#include <bits/stdc++.h>
using namespace std;

void move(char a, char b, int n){
    cout << n << ":" << a << "->" << b << endl;
}
struct Node{
    char a, b, c;
    int n;
    bool flag;
    Node(char a='a', char b='b', char c = 'c', int n=0, bool flag=1)
        : a(a), b(b), c(c), n(n), flag(flag){}
};

stack<Node> sta;

int main(){
    char a,b,c;
    int n;
    cin>>n>>a>>b>>c;
    sta.push(Node(a,b,c,n,1));
    while (sta.size()){
        bool f = sta.top().flag;
        char a = sta.top().a, b = sta.top().b, c = sta.top().c;
        int t = sta.top().n;
        sta.pop();
        if (f == 0 || t == 1){
            move(a,c,t);
            continue;
        }
        sta.push(Node(b,a,c,t-1,1));
        sta.push(Node(a,0,c,t,0));
        sta.push(Node(a,c,b,t-1,1));
    }

    return 0;
}

形式化描述一下

• 设递归调用函数为A，非递归函数为B1, B2, B3, B4
• 对于一个两阶段递归调用的函数A来说，它总可以写成如下形式（暂时忽略了调用参数）

if 满足结束条件
    Call B1
    return
Call B2
Call A
Call B3
Call A
Call B4

• 那么我们的非递归方法可以形式:

define stack<函数名, 函数参数> s
s.push(A，初始参数)
while (s.isempty == false){
    函数名 x = 栈顶元素函数名
    函数参数 y = 栈顶函数参数
    s.pop()
    if x 是非递归函数
       Call x
       continue
    if y 满足结束条件
       Call B1
       continue
    s.push(B4, 参数)
    s.push(A, 参数)
    s.push(B3, 参数)
    s.push(A, 参数)
    s.push(B2, 参数)
}

• 当然更复杂的递归调用函数也可以使用类似方法进行转换