求和的递归、迭代、动态规划实现；

接下来将介绍一个菲波那切数列、阶乘、求和的递归、迭代、动态规划实现和只能用递归实现的汉诺塔；

头文件；

# ifndef _RECURSION_
# define _RECURSION_

# include <iostream>
using namespace std;

//菲波那切数列递归、迭代和动态规划实现；
int FibonacciRecursion(int val);
int FibonacciIteration(int val);
int FibonacciDP(int val);

//阶乘递归、迭代和动态规划实现；
int FactorialRecursion(int val);
int FactorialIteration(int val);
int FactorialDP(int val);

//求和递归、迭代和动态规划实现；
int SumRecursion(int val);
int SumIterator(int val);
int SumDP(int val);

# endif

实现文件；

# include "Recursion.h"

//菲波那切数列递归、迭代和动态规划实现；
//时间复杂度是O(2^n)；
int FibonacciRecursion(int val)
{
	if (1 == val || 2 == val)
	{
		return 1;
	}
	else
	{
		return (FibonacciRecursion(val - 1) + FibonacciRecursion(val - 2));
	}
}

//空间复杂度是O(1)；时间复杂度是O(n)；
int FibonacciIteration(int val)
{
	if (1 == val || 2 == val)
	{
		return 1;
	}
	else
	{
		int f1 = 1;
		int f2 = 1;
		int f3 = 0;

		for (int i = 3; i <= val; i++)
		{
			f3 = f1 + f2;

			f1 = f2;
			f2 = f3;
		}

		return f3;
	}
}

//空间复杂度是O(n)；时间复杂度是O(n)；
int FibonacciDP(int val)
{
	int i = 0;
	int * f = (int *)malloc(sizeof(int) * (val + 1));

	f[1] = 1;
	f[2] = 1;
	for (i = 3; i <= val; i++)
	{
		f[i] = f[i - 1] + f[i - 2];
	}
	val = f[val];
	free(f);

	return val;
}

//阶乘递归、迭代和动态规划实现；
//时间复杂度是O(2^n)；
int FactorialRecursion(int val)
{
	if (1 == val)
	{
		return val;
	}
	else
	{
		return (val * FactorialRecursion(val - 1));
	}
}

//空间复杂度是O(1)；时间复杂度是O(n)；
int FactorialIteration(int val)
{
	int f = 1;

	for (int i = 1; i <= val; i++)
	{
		f = f * i;
	}

	return f;
}

//空间复杂度是O(n)；时间复杂度是O(n)；
int FactorialDP(int val)
{
	int i = 0;
	int * f = (int *)malloc(sizeof(int) * (val + 1));

	f[1] = 1;
	for (i = 2; i <= val; i++)
	{
		f[i] = i * f[i - 1];
	}
	val = f[val];
	free(f);

	return val;
}

//求和递归、迭代和动态规划实现；
//空间复杂度是O(2^n)；
int SumRecursion(int val)
{
	if (1 == val)
	{
		return val;
	}
	else
	{
		return(val + SumRecursion(val - 1));
	}
}

//空间复杂度是O(1)；时间复杂度是O(n)；
int SumIterator(int val)
{
	int sum = 0;
	for (int i = 1; i <= val; i++)
	{
		sum += i;
	}

	return sum;
}

//空间复杂度是O(n)；时间复杂度是O(n)；
int SumDP(int val)
{
	int i = 0;
	int * s = (int *)malloc(sizeof(int) * (val + 1));

	s[1] = 1;
	for (i = 2; i <= val; i++)
	{
		s[i] = i + s[i - 1];
	}
	val = s[val];
	free(s);

	return val;
}

Main函数；

# include "Recursion.h"

int main(int argc, char ** argv)
{
	int i = 0;
	int j = 0;

	cout << endl << "--------------------------Fibonacci--------------------------" << endl;
	for (i = 1; i < 20; i++)
	{
		cout << FibonacciIteration(i) << " ";
	}
	cout << endl << FactorialRecursion(10) << endl;

	cout << endl << "--------------------------Factorial--------------------------" << endl;
	cout << FactorialDP(5) << endl;

	cout << endl << "--------------------------Sum--------------------------" << endl;
	cout << SumRecursion(100) << endl;
	cout << SumIterator(100) << endl;
	cout << SumDP(100) << endl;

	cout << endl << endl;
	system("pause");
	return 0;
}