汉诺塔递归、非递归实现——递归与栈模拟递归的理解

本文链接：https://blog.csdn.net/peng_fighting/article/details/115481662

大一学习递归总是想要弄明白递归程序具体的运行步骤，但无奈一次次“迷失”在递归的迷宫中。。。
递归的精妙之处不在于它能用少量的代码来实现十分复杂的功能，而在于它能表达出“分形”结构。
在数学上的分形我就不展开说了，在编程上的分形简单来说，就是想像一个任务由许许多多工人完成，他们只会机械的做相似的事，自己就是其中的一个最普通的工人，将自己要做的事用代码表达出来。
就汉诺塔来说，自己负责搬运第n块:

先让其他人将自己上面的n-1块从start柱，搬到mid柱，经过end柱。
自己将第n块从start柱，搬到end柱，经过mid柱。
最后让其他人将刚刚的n-1块从mid柱，搬到end柱，经过start柱。
若自己搬的是第0块（没有块）则什么也不做，返回给上一个让自己做事的人。

这样对于每一块的搬运均有一个与自己做同样工作的人完成，整个问题就被解决了。
因此，如果想用递归解题的话，不用考虑具体的递归流程，只需要知道在每个环节需要做什么就可以了。
递归做法：

//递归实现
void hanioDiGui(int n,char start,char mid,char end){
    if(n==0) return;
    else{
        hanioDiGui(n-1,start,end,mid);
        printf("%c -> %c\n",start,end);
        hanioDiGui(n-1,mid,start,end);
    }
}

在大二上数据结构学习栈模拟递归的时候，感觉错综复杂，令人头秃~~
在大二下时学习了在机组mips汇编，了解了系统中函数递归调用的实现机制，函数调用实质上是系统中的栈来实现的。
于是，我想能不能来用机组的原理解决数据结构的问题，借助汇编的写法实现栈模拟递归呢？
其中比较关键的几步类比：

在函数连续调用的时候，需要将寄存器中的值预先储存到栈区，等到返回到这个函数的时候，在将之前“埋”到栈里的值取出，重新存入寄存器中。在这里，我定义了一个status结构体，来模拟描述每个状态的寄存器的值。用stack来模拟栈区
实现递归时有个十分关键的$ra寄存器，它可以记录下一条指令的地址，连续调用时也需要储存进栈区。在本例中，类似于 $ra寄存器，我在status结构体中定义了step变量来记录当前状态下已经进行操作的步数。
在汇编中，实现跳转的"j address"指令我用goto来实现。

代码如下：

//状态结构体定义
typedef struct status{
    int n,step=0; //step记录当前状态运行到的步骤数，功能等同于$ra寄存器。
    char s,m,e;
}Status;

//goto实现
void hanioGoTo(int N,char start,char mid,char end){
    stack<Status*> st;
    Status *stt=new Status;
    stt->n=N;
    stt->s=start,stt->m=mid,stt->e=end;
    st.push(stt);
    DiGui:
        if(!st.empty()){
            Status *stc=st.top();
            int n=stc->n;
            char s=stc->s,m=stc->m,e=stc->e;
            //步骤全部完成或n==0，返回;
            if(stc->step==2||n==0) {
                delete stc; //pop只弹出指针，所以需要手动释放内存，否则内存超限。
                st.pop();
            }
            else if(stc->step==1) {
                printf("%c -> %c\n",s,e);//完成了printf("%c -> %c\n",start,end);
                stt=new Status();
                stt->n=n-1;
                stt->s=m,stt->m=s,stt->e=e;
                st.push(stt);
                (stc->step)++;//完成了hanioDiGui(n-1,mid,start,end);step++
            }
            else if(stc->step==0){
                stt=new Status();
                stt->n=n-1;
                stt->s=s,stt->m=e,stt->e=m;
                st.push(stt);
                (stc->step)++; //完成了hanioDiGui(n-1,start,end,mid); step++
            }
            goto DiGui;
        }
        else goto EXIT;
    EXIT:;
}

将goto稍微改动一下，就完成了while循环实现：

//状态结构体定义
typedef struct status{
    int n,step=0; //step记录当前状态运行到的步骤数，功能等同于$ra寄存器。
    char s,m,e;
}Status;

//while实现
void hanioWhile(int N,char start,char mid,char end){
    stack<Status*> st;
    Status *stt=new Status;
    stt->n=N;
    stt->s=start,stt->m=mid,stt->e=end;
    st.push(stt);
    while(!st.empty()){
        Status *stc=st.top();
        int n=stc->n;
        char s=stc->s,m=stc->m,e=stc->e;
        //步骤全部完成或n==0，返回;
        if(stc->step==2||n==0) {
            delete stc; //pop只弹出指针，所以需要手动释放内存，否则内存超限。
            st.pop();
        }
        else if(stc->step==1) {
            printf("%c -> %c\n",s,e);//完成了printf("%c -> %c\n",start,end);
            stt=new Status();
            stt->n=n-1;
            stt->s=m,stt->m=s,stt->e=e;
            st.push(stt);
            (stc->step)++;//完成了hanioDiGui(n-1,mid,start,end);step++
        }
        else if(stc->step==0){
            stt=new Status();
            stt->n=n-1;
            stt->s=s,stt->m=e,stt->e=m;
            st.push(stt);
            (stc->step)++; //完成了hanioDiGui(n-1,start,end,mid); step++
        }
    }
}

说了这么多，不过是我探索的心路历程。
那么如何给定一个递归代码，迅速的写出while与stack模拟的非递归实现呢？
总结一下：

定义一个状态结构体，里面的变量为递归函数传入的参数以及step变量。（若递归函数中自身只被调用一次，可以不用定义step变量。当递归调用在递归函数末尾的时候，调用后没有其他操作，甚至可以不需要使用栈。）
将状态结构体作为栈的元素，模拟递归的函数调用。其中针对不同的step进行下一步的操作。
当栈为空的时候也就是递归返回到最外层了，则可以结束循环了。

完整代码：

#include<iostream>
#include<stack>
using namespace std;

//递归实现
void hanioDiGui(int n,char start,char mid,char end){
    if(n==0) return;
    else{
        hanioDiGui(n-1,start,end,mid);
        printf("%c -> %c\n",start,end);
        hanioDiGui(n-1,mid,start,end);
    }
}

//状态结构体定义
typedef struct status{
    int n,step=0; //step记录当前状态运行到的步骤数，功能等同于$ra寄存器。
    char s,m,e;
}Status;

//goto实现
void hanioGoTo(int N,char start,char mid,char end){
    stack<Status*> st;
    Status *stt=new Status;
    stt->n=N;
    stt->s=start,stt->m=mid,stt->e=end;
    st.push(stt);
    DG:
        if(!st.empty()){
            Status *stc=st.top();
            int n=stc->n;
            char s=stc->s,m=stc->m,e=stc->e;
            //步骤全部完成或n==0，返回;
            if(stc->step==2||n==0) {
                delete stc; //pop只弹出指针，所以需要手动释放内存，否则内存超限。
                st.pop();
            }
            else if(stc->step==1) {
                printf("%c -> %c\n",s,e);//完成了printf("%c -> %c\n",start,end);
                stt=new Status();
                stt->n=n-1;
                stt->s=m,stt->m=s,stt->e=e;
                st.push(stt);
                (stc->step)++;//完成了hanioDiGui(n-1,mid,start,end);step++
            }
            else if(stc->step==0){
                stt=new Status();
                stt->n=n-1;
                stt->s=s,stt->m=e,stt->e=m;
                st.push(stt);
                (stc->step)++; //完成了hanioDiGui(n-1,start,end,mid); step++
            }
            goto DG;
        }
        else goto EXIT;
    EXIT:;
}

//while实现
void hanioWhile(int N,char start,char mid,char end){
    stack<Status*> st;
    Status *stt=new Status;
    stt->n=N;
    stt->s=start,stt->m=mid,stt->e=end;
    st.push(stt);
    while(!st.empty()){
        Status *stc=st.top();
        int n=stc->n;
        char s=stc->s,m=stc->m,e=stc->e;
        //步骤全部完成或n==0，返回;
        if(stc->step==2||n==0) {
            delete stc; //pop只弹出指针，所以需要手动释放内存，否则内存超限。
            st.pop();
        }
        else if(stc->step==1) {
            printf("%c -> %c\n",s,e);//完成了printf("%c -> %c\n",start,end);
            stt=new Status();
            stt->n=n-1;
            stt->s=m,stt->m=s,stt->e=e;
            st.push(stt);
            (stc->step)++;//完成了hanioDiGui(n-1,mid,start,end);step++
        }
        else if(stc->step==0){
            stt=new Status();
            stt->n=n-1;
            stt->s=s,stt->m=e,stt->e=m;
            st.push(stt);
            (stc->step)++; //完成了hanioDiGui(n-1,start,end,mid); step++
        }
    }
}

int main(){
    int n;
    scanf("%d",&n);
    hanioGoTo(n,'a','b','c');
    return 0;
}