【数据结构】递归程序的非递归实现

用递归代码实现斐波那契数列求解，利用转换规则(不简化) 将递归代码转换为非递归代码。（C++）

求1+2+3+…+n的和：
递归做法

int sum(int n) {
	if (n == 0)
		return 0;
	else {
		return n + sum(n - 1);
	}
}

非递归的实现

#include<iostream>
using namespace std;
#include<stack>
int sum(int n) {//非递归
	if (n == 0)
		return 0;
	stack<int>s;
l0:	if (n > 0) {
		s.push(n);
		n--;
		goto l0;/*本质上是一个循环语句，
				在底层所有的循环语句都是跳转语句组成的*/
	}
	int res = 0;
l1:	res += n;
	if (!s.empty()) {
		n = s.top();
		s.pop();
		goto l1;

	}
	return res;

}
int main() {
	
	cout << sum(100);
	return 0;
}

斐波那契函数的递归

递归程序的非递归实现
看了这篇教程，才懵懵懂懂做出来。

#include<iostream>
using namespace std;
#include<stack>
int fib(int n) {
	if (n == 1 || n == 2)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}
int main() {
	
	cout << fib(5);
	return 0;
}

非递归的实现

#include<iostream>
using namespace std;
#include<stack>
struct SnapShort {
	int n;//保存函数形参
	int retVal;//保存函数返回值
	int stage;//指示当前处于哪个stage
	SnapShort(){
		n = 0;
		retVal = 0;
		stage = 0;

	}
	SnapShort(int n=0, int retVal=0, int stage=0) {
		this->n = n;
		this->retVal = retVal;
		this->stage = stage;
	}
};
int fib(int n) {
	
	stack<SnapShort> s;//保存结构体的栈
	stack<int> result;//保存返回值的栈

	SnapShort currentSnap(n,0,0);
	s.push(currentSnap);
	
	while (!s.empty()) {
		currentSnap = s.top();
		s.pop();
		switch (currentSnap.stage)
		{
		case 0:
		{if (currentSnap.n == 1 || currentSnap.n == 2) {
			result.push(1);
			continue;
		}
		currentSnap.stage = 1;
		s.push(currentSnap);
		SnapShort nextSnap1(currentSnap.n - 1, 0, 0);
		s.push(nextSnap1); }
			break;
		case 1:
		{currentSnap.stage = 2;
		s.push(currentSnap);
		SnapShort nextSnap2(currentSnap.n - 2, 0, 0);
		s.push(nextSnap2); }
			break;
		case 2:
			int a = result.top();
			result.pop();
			int b = result.top();
			result.pop();
			result.push(a + b);
			break;
		}
	}
	return result.top();
}
int main() {
	
	for (int i = 1; i < 10; i++) {
		cout << "fib(" << i << ") = " << fib(i) << "\n";
	}
	return 0;
}

我只能说这个stage用的太妙了，我到现在都没有完全明白其真正的作用，
只能说一句“太妙了”。