【C语言学习】函数递归

1. 什么是递归？

程序调用自身的编程技巧称为递归（ recursion）。
什么是函数递归？
一个函数在它的函数体内调用它自身，这种函数称为递归函数。执行递归函数将反复调用其自身，每调用一次就进入新的一层，当最内层的函数执行完毕后，再一层一层地由里到外退出。

递归的主要思考方式在于：把大事化小

2. 递归的两个必要条件

1. 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
2. 每次递归调用之后越来越接近这个限制条件。
   在下面的例子中，我们逐步体会这2个限制条件。

3. 递归举例

3.1 求n的阶乘

3.1.1 分析和代码实现

我们知道n的阶乘的公式： n! = n ∗ (n − 1)!
举例：

		5! = 5 * 4 * 3 * 2 * 1
 		4! = 4 * 3 * 2 * 1
 所以：	5! = 5 * 4!

这样的思路就是把⼀个较大的问题，转换为⼀个与原问题相似，但规模较小的问题来求解。
把 n! 写成函数形式，即 f(n)，求 n! 的过程可以写成如下形式：

	f(n) = n * f(n-1);
	f(n-1) = (n-1) * f(n-2);
		…
	f(2) = 2 * f(1);
	f(1) = 1;

直到n是1或者0时，不再拆解。
再稍微分析⼀下，当 n<=1 的时候，n的阶乘是1，其余n的阶乘都是可以通过上述公式计算。n的阶乘的递归公式如下：

代码实现：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

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

int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = function(n);
	printf("%d\n", ret);
	return 0;
}

运行结果：

3.1.2 画图推演

递推：

回归：

3.2 顺序打印⼀个整数的每⼀位

3.2.1 分析和代码实现

首先想到的是，怎么得到这个数的每⼀位呢？
如果n为⼀位数，那么n的每⼀位就是n自己；但是如果n超过1位数的话，就得拆分每⼀位。
例如：1234%10 就能得到 4，然后 1234/10 得到 123，这就相当于去掉了4；然后继续对 123%10，就得到了 3，再除 10 去掉 3，以此类推不断的 %10 和 /10 操作，直到 1234 的每⼀位都得到。但是这⾥有个问题就是得到的数字顺序是倒着的。
但是我们有了灵感，我们发现其实⼀个数字的最低位是最容易得到的，通过%10就能得到。那我们假设想写⼀个函数Print来打印n的每⼀位：

	Print(n)
	如果n是1234，那表⽰为
	Print(1234) //打印1234的每⼀位
	其中1234中的4可以通过%10得到，那么
	Print(1234)就可以拆分为两步：
	1. Print(1234/10) //打印123的每⼀位
	2. printf(1234%10) //打印4
	完成上述2步，那就完成了1234每⼀位的打印
	那么Print(123)⼜可以拆分为Print(123/10) + printf(123%10)

以此类推下去，就有

 	Print(1234)
	==>Print(123) + printf(4)
	==>Print(12) + printf(3)
	==>Print(1) + printf(2)
	==>printf(1) 

代码实现：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void print(unsigned int n)
{
	if (n > 9)//stop condition
	{
		print(n / 10);
	}
	printf("%d ", n % 10);
}

int main()
{
	unsigned int num = 0;
	scanf("%u", &num);
	print(num);
	return 0;
}

运行结果：

3.2.2 画图推演

4. 递归与迭代

递归是⼀种很好的编程技巧，但是很多技巧⼀样，也是可能被误用的。就像上述例3.1一样，f(n) 函数是可以产⽣正确的结果，但是在递归函数调⽤的过程中涉及⼀些运⾏时的开销。
在C语⾔中每⼀次函数调用，都要需要为本次函数调用在栈区申请⼀块内存空间来保存函数调用期间的各种局部变量的值，这块空间被称为运⾏时堆栈，或者函数栈帧。
函数不返回，函数对应的栈帧空间就⼀直占用，所以如果函数调用中存在递归调⽤的话，每⼀次递归函数调用都会开辟属于自己的栈帧空间，直到函数递归不再继续，开始回归，才逐层释放栈帧空间。所以如果采用函数递归的⽅式完成代码，递归层次太深，就会浪费太多的栈帧空间，也可能引起栈溢出（stack over flow）的问题。
如果不想使用递归就得想其他的办法，通常就是迭代的方式（通常就是循环的⽅式）。
比如说，我们采用迭代的方法来计算 n 的阶乘：

int Fact(int n)
{
	int i = 0;
	int ret = 1;
	for(i = 1; i <= n; i++)
	{
		ret = ret * i;
	}
	return ret;
}

上述代码是能够完成任务，而且效率比递归的方式更好。
事实上，我们看到的许多问题是以递归的形式进⾏解释的，这只是因为它比非递归的形式更加清晰，但是这些问题的迭代实现往往比递归实现效率更高。
当⼀个问题非常复杂，难以使⽤迭代的⽅式实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。

比如，计算第 n 个斐波纳契数：

看到上面的公式，我们很容易就能想到利用递归的方法求解问题：

int Fib(int n)
{
 	if(n<=2)
 		return 1;
 	else
 		return Fib(n-1)+Fib(n-2);
}

总代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int fib(int n)
{
	if (n <= 2)
	{
		return 1;
	}
	else
	{
		return fib(n - 1) + fib(n - 2);
	}
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = fib(n);
	printf("%d\n", ret);
	return 0;
}

当我们输入值为60的时候，需要很⻓时间才能算出结果。

这也说明递归的写法是非常低效的，那是为什么呢？下面我将以画图推演的方式进行解释。
其实递归程序会不断的展开，在展开的过程中，我们很容易就能发现，在递归的过程中会有重复计
算，⽽且递归层次越深，冗余计算就会越多。
所以斐波那契数的计算，使⽤递归是⾮常不明智的，我们就得想迭代的⽅式解决。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int Fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 1;
	while (n>2)
	{
		c = a + b;
		a = b;
		b = c;
		n--;
	}
	return c;
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = Fib(n);
	printf("%d\n", ret);
	return 0;
}

运行结果：

迭代的⽅式去实现这个代码，效率就要⾼出很多了。
有时候，递归虽好，但是也会引入⼀些问题，所以我们⼀定不要迷恋递归，适可而止就好😎。