1.递归的定义
在C 语言中，递归就是函数自己调用自己
上面的代码就是 main 函数在函数主体内 自己调用自己
但是，上面的代码存在问题：main 函数反复地 自己调用自己 ，不受限制，停不下来。
最终形成死递归，导致栈溢出
1.0栈溢出
每一次函数调用，都要从内存上的栈区为这次函数调用分配内存空间
栈区的大小是有限的，如果无限的调用函数就会导致栈区空间被使用完，
从而发生栈溢出的现象，导致程序运行停止
1.1递归的思想
将一个大问题细分为一个个子问题，直到子问题不可拆分为止就是递归的思想。
递归就是将大事化小的过程。
递，就是递推；归，就是回归。
1.2.递归的书写条件
（1）递归存在限制条件，当条件满足时，递归便不再继续
（2）每次递归调用之后，越来越接近这个限制条件
2.举例
2.1阶乘
我们知道，n! = n * (n-1) * (n-2) * (n-3) * ......* 2 * 1
又注意到，2! = 2 * 1! || 3! = 3 * 2! || 4! = 4 * 3!
所以 n! = n * (n -1)!
int Fact1(int n)
{
if (n == 0)
return 1;
else return n * Fact1(n - 1);
}
当 n = 3 时
Fact1(3) = 3*Fact1(2)
Fact1(2) = 2*Fact1(1)
Fact1(1) = 1*Fact1(0)
Fact1(0) = 1
先是递推，每次函数调用之后，接近 n 等于 0 这个限制条件
然后回归
Fact1(0) = 1
Fact1(1) = 1*Fact1(0) = 1
Fact1(2) = 2*Fact1(1) = 2
Fact1(3) = 3*Fact1(2) = 6
2.2顺序打印整数的每一位
运用递归时，我们要相信我们所创建的函数能够完成相应的任务
例如，顺序打印 123 中的每一位
void Print1(int n)
{
if (n > 9)
Print1(n / 10);
printf("%d ", n % 10);
}
在上面的代码实现中：
Print(123)中 123 > 9 所以 先调用函数**Print(123/10)**打印 12 再打印3
Print(123 / 10)中 12 > 9 所以 先调用函数**Print(12/10)**打印 1 再打印2，
Print(12 / 10)中 1 < 9 开始 打印 1，函数**Print(12 / 10)**调用完毕
然后返回函数Print(123 / 10) 打印 2， 再返回函数**Print(123)**打印3
Print(123） -> Print(123 / 10) -> Print(12 / 10)
这是递推， 将 大问题转化位 小问题， 只打印个位数
Print(12 / 10) - > Print(123 / 10） -> Print(123)
这是回归 ，因为只有函数调用任务实现后，才会继续后面的操作
2.3斐波那契数列
1，1，2，3，5，8，13，21，34........
第一二个数为1，其余的数等于前两个数相加，就是斐波那契数列的规律
代码实现：
int Fib(int n)
{
if (n < 3)
return 1;
else return Fib(n - 1) + Fib(n - 2);
}
例如 n = 4
Fib(4) = Fib(3) + Fib(2)
Fib(3) = Fib(2) + Fib(1)
Fib(2) = 1
这是递推，然后回归
Fib(3) = 1 +Fib(1)
Fib(1) = 1
所以Fib(3) = 1+ 1 = 2
继续回归
Fib(4) = 2 + Fib(2)
Fib(2) = 1
Fib(4) = 2 +1 = 3
注意：只用当前一个Fib函数调用完毕后才会调用后面的Fib函数
3.递归与迭代
上述例子用递归的思想实现时，代码较为简洁
但不可避免的是，如果递归的层次太深，栈溢出的现象就不可避免
所谓层次太深，就是说许多函数被调用后，未被销毁，依然占据着栈区的部分内存
最终导致栈区空间被使用完，出现栈溢出的现象
虽然存在限制条件 n > 10000 但是 3988次调用之后，程序就自动停止了 ，
因为递归层次太深，出现了栈溢出的现象
注意到，Fib函数虽然被调用了很多次，但是却没有出现栈溢出的现象
这是因为Fib(40)最深只会调用40次，然后就会被销毁，再继续后面的调用
..........................................................................................................................................
注意到，Fib(40)重复调用的Fib函数太多，运行效率非常低
此时就可以采用迭代的方法实现斐波那契数列。
循环是一种迭代，迭代不仅仅是循环
int Fact2(int n)
{
int a = 1;//前两个数
int b = 1;//前一个数
int c = 1;//当前的数
//当n 小于等于 2时
//直接返回c 为 1
//当n 大于 2时
//1 + 1 = 2 1+ 2 = 3 2+ 3 = 5
//第n个数需要迭代n-2次
for (int i = 0; i < n - 2; ++i)
{
c = a + b;
a = b;
b = c;
}
return c;
}
运行一下就知道，迭代实现斐波那契数列比递归更快！
但是解决实际问题时
递归比较好想，如果能保证不会出现栈溢出等问题就可优先考虑使用递归
其次是迭代