函数的递归调用，其算法复杂度（c语言）——（斐波那契数列，汉诺塔）

递归调用：

        递归调用就是在当前的函数中调用当前的函数并传给相应的参数，这是一个动作，这一动作是层层进行的，直到满足一般情况的的时候，才停止递归调用，开始从最后一个递归调用返回。

如：用递归实现n的阶乘

int Fac(int n)
{
	if(n==0 || n==1)
	{
		return 1;
	}
	else 
		return Fac(n-1) * n;
}

当n=5时，Fac(5)函数调用Fac(4)，Fac(4)调用Fac(3) ... ...到Fac(1) 或 Fac(0)时，才开始返回；

比较“递归”和“循环”（斐波那契数列）：

#include <stdio.h>

int Fibon1(int n)//循环，实现斐波那契数列
{
	int f1=1,f2=1,f3=1;
	for(int i=2;i<n;i++)
	{
		f3=f1+f2;
		f1=f2;
		f2=f3;
	}
	return f3;
}
int Fibon2(int n)//递归调用，实现斐波那契数列
{
	if(n==1 || n==2)
	{
		return 1;
	}
	return Fibon2(n-1)+Fibon2(n-2);
}
int main()
{
	printf("%d\n",Fibon1(5));
	printf("%d\n",Fibon2(5));
	return 0;
}

  算法复空间杂度分为时间复杂度和空间复杂度。其作用： 时间复杂度是指执行算法所需要的计算工作量；而复杂度是指执行这个算法所需要的内存空间。（算法的复杂性体现在运行该算法时的计算机所需资源的多少上，计算机资源最重要的是时间和空间（即寄存器）资源，因此复杂度分为时间和空间复杂度）。

如：for(int i=1;i<=n;++i)         // (1) 该语句时间复杂度：1+n+n

          for(int j=1;j<=n;++j)      //(2)该语句时间复杂度：(2n+1)*n

            {     s[i][j]=0;                 //(3)该语句时间复杂度：n*n

              .....

   当n无限大时，所有一次项可以忽略，所以整体时间复杂度为O(n^2)。其所有变量存入一个栈，所以空间复杂度为O(1)。

通过算法复杂度分析两者的区别：

递归调用：

函数具体实现过程：

函数的存储：

即，“循环”的时间复杂度：O(n)；  空间复杂度：O(1)；

       “递归”的时间复杂度：O(n);     空间复杂度：O(n)；

显然“递归调用”在处理大数据的时候，需要大量时间和内存，并且容易超出栈的大小。

所以求斐波那契数列不适合用递归调用！

但也有非常适用的时候！

           ——汉诺塔问题。

#inlcude <stdio.h>
int g_count = 0;

void Move(char x,char y)
{
	g_count++;
	printf("%c->%c\n",x,y);
}

void Hanoi(int n,char a,char b,char c)
{
	if(n == 1)
	{
		Move(a,c);
	}
	else
	{
		Hanoi(n-1,a,c,b);
		Move(a,c);
		Hanoi(n-1,b,a,c);
	}
}

int main()
{
	Hanoi(4,'A','B','C');
	printf("%d\n",g_count);
        return 0;
}