一类void 递归函数的非递归实现

        对于如下类型的void型递归函数：(主要特征是递归调用的地方上下文无关)

        void Fun(type a1,type a2......)
        {
                //0号程序段-起
                //0号程序段-止

                Fun(b1,b2,.....);
                //1号程序段-起            -----注意0,1,...号程序段之间并无上下文关联(没有共享局部变量)
                //1号程序段-止
                Fun(c1,c2,.....);
                //2号程序段-起
                //2号程序段-止
.........
        }

将函数(程序段)一次调用视为一个节点，就可以将递归函数整个一次的执行看做是树的遍历：

如函数:

        void Test(int n){
                if(n>1){
                        Test(n-1);
                        printf("Test%d\n",n);
                        Test(n-2);
                }
        }

                    Test(n)函数

                        O      (root节点)       ----------Test函数,即if(n>1){   A   }

                         |                                

                        O                               ----------A

      /                  |                \

   O                  O                O

  Test(n-1)    Printf...      Test（n-2）

继续向下...     执行          继续向下.....

将图中的节点编号，Test函数节点为-1;A程序段编号为0；printf程序段编号为1；

struct Param
{
        int number;
        int n;
}
void  Test(int n)
{
        stack<Param> ss;
        Param p;
        p.number = -1;p.n = n;
        ss.put(p);
        while(!ss.empty)
        {
                Param pa = ss.top();
                ss.pop();//原递归函数为void型，不需要回溯
                switch(ss.number){
                        case -1://-1号节点Test函数节点
                                if(ss.n>1){
                                        pa.number = 0;
                                        pa.n = n;
                                        ss.push(pa);
                                }
                                break;
                        case 0://0号节点A程序段节点,即:Test(n-1);printf("Test%d\n",n);Test(n-2);

                                //Test(n-2)节点压入栈中
                                pa.number = -1;
                                pa.n = n-2;
                                ss.push(pa);

                                //printf程序段压入栈中
                                pa.number = 1;
                                //pa.n = 0;//这个参数没有意义
                                ss.push(pa);

                                //Test(n-1)节点压入栈中
                                pa.number = -1;
                                pa.n = n-1;
                                ss.push(pa);
                                break;
                        case 1://printf函数段，即：printf("Test%d\n",n);
                                printf("Test%d\n",n);
                                break;
                }
        }
}

稍作简化,因为-1号节点后继节点只有一个节点,直接将两个节点合并(使用合并可能不是特别贴切)了:

                    Test(n)函数

                        O      (root节点)       ----------Test函数                               

      /                  |                \

   O                  O                O

  Test(n-1)    Printf...      Test（n-2）

继续向下...     执行          继续向下.....

将Test节点编号为-1,Printf节点编号为0;

void  Test(int n)
{
        stack<Param> ss;
        Param p;
        p.number = -1;p.n = n;
        ss.put(p);
        while(!ss.empty)
        {
                Param pa = ss.top();
                ss.pop();//原递归函数为void型，不需要回溯
                switch(ss.number){
                        case -1://-1号节点Test函数节点
                                if(ss.n>1){
                                        //Test(n-2)节点压入栈中
                                        pa.number = -1;
                                        pa.n = n-2;
                                        ss.push(pa);

                                        //printf程序段压入栈中
                                        pa.number = 1;
                                        //pa.n = 0;//这个参数没有意义
                                        ss.push(pa);

                                        //Test(n-1)节点压入栈中
                                        pa.number = -1;
                                        pa.n = n-1;
                                        ss.push(pa);
                                }
                                break;
                        case 0://printf函数段，即：printf("Test%d\n",n);
                                printf("Test%d\n",n);
                                break;
                }
        }
}

说明:

1、注意压栈的顺序，反向压栈

2、本方法只是用于递归调用的地方不需要保存现场（Test函数递归调用前后没有关联）

如果Test函数是这样的：

void Test(int n){
        if(n>1){
                int t = 1;
                Test(n-1);
                t = 0;
                Test(n-2);
        }
}

由于t变量的存在，因此需要额外的空间保存t的值(天知道t需不需要使用到)，不属于本文讨论的此类递归函数

3、递归函数不能有返回值（之后可能会讨论这样的递归函数）