系统递归和自己用栈实现递归的比较

在dfs或者一些场合中，我们都会用到递归，提到递归大家都知道，是系统用系统栈帮助我们来存储数据。同样我们也可以用自己的栈来实现递归。现在我再dfs（深度优先搜索）的基础上来淘淘下，系统递归和自己用栈实现递归在程序运行时间上的比较。我的程序是一道类似于求24点的dfs算法的题

程序1（用stl的stack来实现dfs）

#include<iostream>
#include <iomanip>
#include<stdio.h>
#include<cmath>
#include<iomanip>
#include<list>
#include <map>
#include <vector>
#include <string>
#include <algorithm>
#include <sstream>
#include <stack>
#include<queue>
#include<string.h>
#include<set>
using namespace std;

int main()
{
	int n;
	//cin>>n;
	scanf("%d",&n);
	for(int xx=0;xx<n;xx++)
	{
		int num[5];
		int goal;
		for(int i=0;i<5;i++)
		{
			//cin>>num[i];
			scanf("%d",num+i);
		}
		//cin>>goal;
		scanf("%d",&goal);
		int Max=-9999;
		clock_t start=clock();
		bool flag=false;
		stack< vector<int> >st;
		vector<int> init(num,num+5);
		st.push(init);
		while(!st.empty())
		{
			vector<int> to=st.top();
			st.pop();
			for(int i=0;i<to.size();i++)
			{
				if(to[i]==goal)
				{
					flag=true;
					break;
				}
				else if(to[i]<goal&&to[i]>Max)
				{
					Max=to[i];
				}
			}
			for(int i=0;i<to.size();i++)
			{
				for(int j=i+1;j<to.size();j++)
				{
					vector<int> baseTmp;
					for(int k=0;k<to.size();k++)
					{
						if(k!=i&&k!=j)
							baseTmp.push_back(to[k]);
					}

					vector<int> plusTmp(baseTmp);
					plusTmp.push_back(to[i]+to[j]);
					st.push(plusTmp);

					vector<int> minusTmp1(baseTmp);
					minusTmp1.push_back(to[i]-to[j]);
					st.push(minusTmp1);

					vector<int> minusTmp2(baseTmp);
					minusTmp2.push_back(to[j]-to[i]);
					st.push(minusTmp2);

					vector<int> multiplyTmp(baseTmp);
					multiplyTmp.push_back(to[i]*to[j]);
					st.push(multiplyTmp);

					if(to[i]==0||to[j]==0)
						continue;
					if(max(to[i],to[j])%min(to[i],to[j])==0)
					{
						vector<int> divideTmp(baseTmp);
						divideTmp.push_back(max(to[i],to[j])/min(to[i],to[j]));
						st.push(divideTmp);
					}
				}
			}
		}
		if(flag)
			printf("%d\n",goal);
		else printf("%d\n",Max);
		clock_t end=clock();
		double Total_time = (double)(end-start) / CLOCKS_PER_SEC; 
		printf( "%f seconds/n", Total_time); 
	}
}

测试结果：

程序2：（用系统递归实现dfs）

#include<iostream>
#include <iomanip>
#include<stdio.h>
#include<cmath>
#include<iomanip>
#include<list>
#include <map>
#include <vector>
#include <string>
#include <algorithm>
#include <sstream>
#include <stack>
#include<queue>
#include<string.h>
#include<set>
using namespace std;

int Max,goal;

bool dfs(vector<long long> &to)
{
	for(int i=0;i<to.size();i++)
	{
		if(to[i]==goal)
		{
			return true;
		}
		else if(to[i]<goal&&to[i]>Max)
		{
			Max=to[i];
		}
	}
	for(int i=0;i<to.size();i++)
	{
		for(int j=i+1;j<to.size();j++)
		{
			vector<long long> baseTmp;
			for(int k=0;k<to.size();k++)
			{
				if(k!=i&&k!=j)
					baseTmp.push_back(to[k]);
			}

			vector<long long> plusTmp(baseTmp);
			plusTmp.push_back(to[i]+to[j]);
			if(dfs(plusTmp))
				return true;

			vector<long long> minusTmp1(baseTmp);
			minusTmp1.push_back(to[i]-to[j]);
			if(dfs(minusTmp1))
				return true;

			vector<long long> minusTmp2(baseTmp);
			minusTmp2.push_back(to[j]-to[i]);
			if(dfs(minusTmp2))
				return true;

			vector<long long> multiplyTmp(baseTmp);
			multiplyTmp.push_back(to[i]*to[j]);
			if(dfs(multiplyTmp))
				return true;

			if(to[i]==0||to[j]==0)
				continue;
			if(max(to[i],to[j])%min(to[i],to[j])==0)
			{
				vector<long long> divideTmp(baseTmp);
				divideTmp.push_back(max(to[i],to[j])/min(to[i],to[j]));
				if(dfs(divideTmp))
					return true;
			}
		}
	}
	return false;
}

int main()
{
	int n;
	//cin>>n;
	scanf("%d",&n);
	for(int xx=0;xx<n;xx++)
	{
		vector<long long> num(5);
		goal;
		for(int i=0;i<5;i++)
		{
			//cin>>num[i];
			scanf("%d",&num[i]);
		}
		//cin>>goal;
		scanf("%d",&goal);
		Max=-9999;
		clock_t start=clock();
		if(dfs(num))
			printf("%d\n",goal);
		else printf("%d\n",Max);
		clock_t end=clock();
		double Total_time = (double)(end-start) / CLOCKS_PER_SEC; 
		printf( "%f seconds/n", Total_time); 
	}
}

结果：

可以看出系统递归比自己栈实现的递归运行时间少了四倍多，究其原因，可能系统用系统栈的开销比我们自己的栈性能好很多，所以在递归比较多的时候，还是选用函数递归吧