刚刚计算机组成原理讲到汇编语言的递归，很受启发，所以分享一个用模拟栈实现递归的通用方法。

在模拟递归过程中之前，肯定先得把递归过程弄明白

比如对于下面的递归（伪代码）：

void dfs(int a0,int a1,...)
{
	{
		代码块0;
	}
	dfs(a00,a11,...);
	{
		代码块1;
	}
}

它的执行过程如下：

总的来说递归过程分为以下五步：

  1. 执行代码块0
  2. 保存现场准备进入下一层
  3. 接受下层返回的数据
  4. 恢复现场
  5. 继续执行代码块1

上述五步相当重要

在直接用递归程序实现递归时，第二步和第四步都是编译器在帮助你完成。而手写递归则需要自己用模拟栈来实现保存现场和恢复现场。

接下来讲如何实现用模拟栈来实现

先约定我们的变量名称

//命名方式是遵从的是 汇编语言MIPS指令里面对应的寄存器编号
int ret;//不同递归层相互通信的信使，也就是存放的普通递归里面return里面的值
struct data
{
	int a0,a1,a2,a3;//表示递归函数输入参数和部分保存的“现场数据”
	int v0;//该层递归结束时的返回值
	int ra;//地址，记录应该执行哪个代码块了
}

然后看一个最简单的例子递归实现n阶乘和手写递归实现n阶乘

good luck and have fun!!!

#include<bits/stdc++.h>
using namespace std;
int fact1(int n)
{
	if(n==1) return 1;
	else return n*fact1(n-1);
}
int fact2(int n)
{
	int ret;
	struct data
	{
		int a0;
		int v0;
		int ra;
	};
	stack<data> S;
	S.push({n,0,0});//递归栈初始化，ra=0表示先进入代码块0
	while(!S.empty())
	{
		data now=S.top();S.pop();
		int a0=now.a0;
		int ra=now.ra;
		int v0=now.v0;
		switch(ra)
		{
			case 0:
			{
				if(a0==1)//递归结束条件
				{
					S.push({a0,1,1});//此条语句也可省略
					ret=1;//将本层返回值传给ret
				}
				else
				{
					S.push({a0,v0,1});//本层入栈，排队准备进入代码块1
					S.push({a0-1,v0,0});//下一层入栈，马上执行代码块0
				}
				continue;
			}
			case 1:
			{
				v0=a0*ret;//将下层的返回值和自己的a0相乘并变为自己的返回值
				ret=v0;//将自己的返回值赋给ret，供自己的上一层使用
				continue;//不会有push语句，也就是对应正常递归里面的本层执行完毕就注销内存了
			}
		}
	}
	return ret;
}
int main(void)
{
	int n1=fact1(10);
	int n2=fact2(10);
	printf("%d %d\n", n1,n2);
}

如果看懂了上面的例子，基本上就学会了模拟栈手写递归的大框架了

接下来再介绍几个稍复杂一点的例子

求斐波拉契数列的第n项

很显然原递归程序有分成了三个代码块（也就是有两个递归调用）

good luck and have fun!!!

#include<bits/stdc++.h>
using namespace std;
//代码风格略有变化。。。
int fib1(int n)
{
	if(n==1||n==0) return 1;
	else return fib1(n-1)+fib1(n-2);
}

int fib2(int n)
{
	int ret;
	struct data
	{
		int a0,ra,v0;
	};
	stack<data> S;
	S.push({n,0,0});
	while(!S.empty())
	{
		data now=S.top();S.pop();
		switch(now.ra)
		{
			case 0:
			{
				if(now.a0==1||now.a0==0)
				{
					now.v0=1;
					ret=now.v0;
				}
				else
				{
					now.ra=1;
					S.push(now);
					S.push({now.a0-1,0,0});
				}
				continue;
			}
			case 1:
			{
				now.v0=ret;//第一次递归回来，用v0暂存返回值
				now.ra=2;
				S.push(now);
				S.push({now.a0-2,0,0});
				continue;
			}
			case 2:
			{
				now.v0+=ret;//第二次递归回来将本次下层的返回值与在代码块1里面暂存的值相加
				ret=now.v0;
				continue;
			}
		}
	}
	return ret;
}

int main(void)
{
	int f1=fib1(10);
	int f2=fib2(10);
	printf("%d %d\n", f1,f2);
}

求全排列

没有返回值的模拟递归

good luck and have fun!!!

#include<bits/stdc++.h>
using namespace std;
int ans[5];
int vis[5];
void permutation1(int k,int n)
{
	if(k==n)
	{
		for(int i=0;i<n;i++)
			printf("%d ", ans[i]);
		printf("\n");
		return ;
	}
	for(int i=0;i<n;i++)
	{
		if(!vis[i])
		{
			ans[k]=i;
			vis[i]=1;
			permutation1(k+1,n);
			vis[i]=0;
		}
	}
}
void permutation2(int k,int n)
{
	struct data
	{
		int a0,a1,a2,ra;
	};
	stack<data> S;
	S.push({k,n,0,0});
	while(!S.empty())
	{
		data now=S.top();S.pop();
		int a0=now.a0,a1=now.a1,ra=now.ra,a2=now.a2;
		switch(ra)
		{
			case 0:
			{
				if(a0==a1)
				{
					for(int i=0;i<a1;i++)
						printf("%d ", ans[i]);
					printf("\n");
					continue;
				}
				for(int i=a2;i<a1;i++)
				{
					if(!vis[i])
					{
						ans[a0]=i;
						vis[i]=1;
						S.push({a0,a1,i,1});//i值是“现场数据”需要记录的
						S.push({a0+1,a1,0,0});
						break;//注意break
					}
				}
				continue;
			}
			case 1:
			{
				vis[a2]=0;
				S.push({a0,a1,a2+1,0});
			}
		}
	}
}

int main(void)
{
	for(int i=0;i<5;i++)
		vis[i]=0;
	permutation1(0,5);
	printf("------------\n");
	for(int i=0;i<5;i++)
		vis[i]=0;
	permutation2(0,5);
}

最后一个求全组合的例子
看到这儿自己也应该会写了吧，其实比全排列还简单一点点

good luck and have fun!!!

#include<bits/stdc++.h>
using namespace std;
int ans[5],vis[5];
void dfs1(int k,int n,int m,int st)
{
	if(k==m)
	{
		for(int i=0;i<m;i++)
			printf("%d ", ans[i]);
		printf("\n");
		return ;
	}
	for(int i=st;i<n;i++)
	{
		ans[k]=i;
		dfs1(k+1,n,m,i+1);
	}
}

void dfs2(int k,int n,int m,int st)
{
	struct data
	{
		int a0,a1,a2,a3,ra;
	};
	stack<data> S;
	S.push({k,n,m,st,0});
	while(!S.empty())
	{
		data now=S.top();S.pop();
		int a0=now.a0,a1=now.a1,a2=now.a2,a3=now.a3,ra=now.ra;
		switch(ra)
		{
			case 0:
			{
				if(a0==a2)
				{
					for(int i=0;i<a2;i++)
						printf("%d ", ans[i]);
					printf("\n");
					continue;
				}
				for(int i=a3;i<a1;i++)
				{
					ans[a0]=i;
					S.push({a0,a1,a2,a3,1});
					S.push({a0+1,a1,a2,a3+1,0});
					break;
				}
				continue;
			}
			case 1:
			{
				S.push({a0,a1,a2,a3+1,0});
			}
		}
	}
}

int main(void)
{
	for(int i=0;i<5;i++)
		vis[i]=0;
	dfs1(0,5,3,0);
	printf("------------\n");
	for(int i=0;i<5;i++)
		vis[i]=0;
	dfs2(0,5,3,0);
}