【C语言】函数递归

1. 递归是什么？

递归是学习C语⾔函数绕不开的⼀个话题，那什么是递归呢？

递归其实是⼀种解决问题的⽅法，在C语⾔中，递归就是函数自己调自己。

我们知道main函数是主函数，所以main函数自己调用自己其实就是一个简单的递归

我们就能写出这个简单的代码：

#include <stdio.h>
int main()
{
    printf("hehe\n");
    main();//main函数中⼜调⽤了main函数
    return 0;
}

上述就是⼀个简单的递归程序，只不过上面的递归只是为了演示递归的基本形式，不是为了解决问题，代码最终也会陷⼊死递归，导致栈溢出（Stack overflow）。

 

 

递归的思想：

把⼀个⼤型复杂问题层层转化为⼀个与原问题相似，但规模较⼩的⼦问题来求解；

直到⼦问题不能再被拆分，递归就结束了。所以递归的思考⽅式就是把大事化小的过程。

“递归” 这个词中的 递 就是 递推 的意思，归 就是 回归 的意思，接下来慢慢体会。

 2. 递归的限制条件

递归在书写的时候，有2个必要条件：

• 递归存在限制条件，当满⾜这个限制条件的时候，递归便不再继续。

• 每次递归调⽤之后越来越接近这个限制条件。

在下⾯的例⼦中，我们逐步体会这2个限制条件。

3. 递归举例

3.1 举例1：求n的阶乘

写一个代码：计算n的阶乘（不考虑溢出）

n的阶乘就是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!---> n*(n-1)!

               (n-1)! ---> (n-1)*(n-2)!

                               ....

                                 1！ = 1*0！

直到n是0时，不再拆解。

另外，我们再稍微分析⼀下，

当n为负数，阶乘是不存在的，返回无意义值-1

当n=0或n=1时，0！=1 ，1！=1 即 Fact(n) = 1

否则，n的阶乘即Fact(n)=n*Fact(n-1)。

因此，n的阶乘的递归公式如下：

那我们就可以写出函数Fact求n的阶乘，

假设Fact(n)就是求n的阶乘，那么Fact(n-1)就是求n-1的阶乘，函数如下：

int Fact(int n)
{
	if (n < 0)                  	/*n<0时阶乘无定义*/
	{
		printf("参数错!");
		return -1;
	}
	if (n == 0)					/*n==0时阶乘为1*/
		return 1;
	else
	{
		return n*Fact(n - 1);		/*递归求n的阶乘*/
	}
}

 测试：

int Fact(int n)
{
	if (n < 0)                  
	{
		printf("参数错!");
		return -1;
	}
	if (n == 0)					
		return 1;
	else
	{
		return n * Fact(n - 1);	
	}
}

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

运⾏结果（这⾥不考虑n太⼤的情况，n太⼤存在溢出）：
 

 

3.1.2 画图推演

接下来我就以求5的阶乘为例，带大家看一下它的递归过程。

 3.2 举例2：顺序打印⼀个整数的每⼀位

输⼊⼀个整数n，打印这个按照顺序打印整数的每⼀位。 ⽐如：

输⼊：1234 输出：1 2 3 4

输⼊：520 输出：5 2 0

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) -> Print(123) //打印123的每⼀位
2. printf(1234%10) -> Print(4) //打印4
完成上述2步，那就完成了1234每⼀位的打印
那么Print(123)⼜可以拆分为Print(123/10) + printf(123%10)，即 Print(12) + Print(3)

以此类推下去，就有

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

 直到被打印的数字变成⼀位数的时候，就不需要再拆分，递归结束。

那么按照刚才的思路实现代码，也就⽐较清楚：

void Print(int n)
{
	if (n > 9)//n至少为2个数
	{
		Print(n / 10);
	}
	printf("%d ", n % 10);
}

int main()
{
	int m = 0;
	scanf("%d", &m);
	Print(m);
	return 0;
}

 在解决这个问题的过程中，我们就是使⽤了 “递归的特点：把⼤事化⼩” 的思路

把Print(1234) 打印1234每⼀位，拆解为⾸先Print(123)打印123的每⼀位，再打印得到的4

把Print(123) 打印123每⼀位，拆解为⾸先Print(12)打印12的每⼀位，再打印得到的3

一直到Print打印的是⼀位数，直接打印就⾏。

3.2.2 画图推演

以1234每⼀位的打印来推演⼀下

 上面流程图中，灰色的线表示 “递”， 即“递推”，橙色的线表示“归”，即回归。

3.3 举例3：求第n个斐波那契数

问题引入 - 什么是斐波那契数列？ 

斐波那契数列中，第n项为n-1和n-2项之和，

形如这样的：

1，1，2，3，5，8，13，21，34，55……

该数列的规律为：从第三个数开始，每一个数等于前两个数之和。 

怎么实现呢？

斐波那契数的问题可以通过递归的形式描述

我们发现：第一项，第二项都是1；从第三项开始，就是前两个数的和。

假如有一个求斐波那契数的函数Fib()，那么求第n个斐波那契数，我们就有这样一个递推公式

 

根据公式，我们就很容易实现这个代码了

#include <stdio.h>

int Fib(int n)
{
	if (n == 1 || n == 2)通过数列的规律发现,前两项都为1,作为递归的终止条件
		return 1;
	else
		return Fib(n - 1) + Fib(n - 2);要求第n项,就是求n-1项和n-2项的和
}

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

输出结果:

 

 

4. 递归与迭代

递归是⼀种很好的编程技巧，但是很多技巧⼀样，也是可能被误⽤的，

就像举例1⼀样，看到推导的公式，很容易就被写成递归的形式：
 

 

Fact函数是可以产⽣正确的结果，但是在递归函数调⽤的过程中涉及⼀些运⾏时的开销。
 

在C语⾔中每⼀次函数调⽤，都要需要为本次函数调⽤在栈区申请⼀块内存空间来保存函数调⽤期间的各种局部变量的值，这块空间被称为函数栈帧。

函数不返回，函数对应的栈帧空间就⼀直占⽤，所以如果函数调⽤中存在递归调⽤的话，每⼀次递归函数调⽤都会开辟属于⾃⼰的栈帧空间，直到函数递归不再继续，开始回归，才逐层释放栈帧空间。

所以如果采⽤函数递归的⽅式完成代码，递归层次太深，就会浪费太多的栈帧空间，也可能引起栈溢出（stack overflow）的问题。

 那么函数栈帧是什么呢？它具体是怎么创建和销毁的？有兴趣的同学 大家可以自行探究学习。

也就是说，比如求50的阶乘时，使用递归的方法求解，会非常吃力，

因为Fact函数递归层次太深，就会浪费太多的栈帧空间，导致效率降低。

所以有时递归实现简单。但是会影响我们的性能问题。

所以如果不想使⽤递归就得想其他的办法，通常就是迭代的⽅式（通常就是循环的⽅式）。

⽐如：计算n的阶乘，也是可以产⽣1~n的数字累计乘在⼀起的。

相信大家应该熟练掌握了！使用循环的方法就可以实现

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

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

上述代码是能够完成任务，并且效率是⽐递归的⽅式更好的。

再比如说，上面讲到的举例3，求第n个斐波那契数 

这个代码根据总结的递推公式，我们很容易实现出来

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

#include <stdio.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = Fib(n);
	printf("%d\n", ret);
	return 0;
}

但是会求出所有的斐波那契数吗？

当我们n输⼊为50的时候，也就是求第50个斐波那契数。需要很⻓时间才能算出结果，有兴趣的同学可以测试一下，大约需要6-7分钟，甚至慢的电脑10分钟才能求出，这个计算所花费的时间，是我们很难接受的，这也说明递归的写法是⾮常低效的，这是为什么呢？我们思考一下使用递归实现斐波那契数列是否存在一些问题？

我们如果画出它的整个递归过程，你会发现

求第50个斐波那契数时，我们要知道第49个，和第48个，

第49个要知道第48个，第47个，

第48个要知道第47个，第46个；第47个要知道第46个，第45个

就会画出如下图所示的递归过程：

其实递归程序会不断的展开，在展开的过程中，

我们很容易就能发现，在递归的过程中会有重复大量的计算，

⽽且递归层次越深，冗余计算就会越多。

我们可以测试一个代码：

#include <stdio.h>

int count = 0;//全局变量

int Fib(int n)
{
	if (n == 3)
		count++;//统计第3个斐波那契数被计算的次数
	if (n == 1 || 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);
	printf("\ncount = %d\n", count);
	return 0;
}

我们测试一看：

这里我们看到了，在计算第40个斐波那契数的时候，使用递归方式，第3个斐波那契数就被重复计算了39088169次，这些计算是非常冗余的。所以斐波那契数的计算，使用递归是非常不明智的，我们就得想迭代的方式解决。 

我们知道斐波那契数的前2个数都1，然后前2个数相加就是第3个数，

那么我们从前往后，从⼩到⼤计算就⾏了。

分析：

 

代码如下：

#include <stdio.h>

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

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

代码解释：

在函数 Fib 中，初始设置了前两个数 a 和 b 都为 1 ，然后通过一个循环来计算后续的数值。在每次循环中，将 a 更新为 b 的值，b 更新为当前的 c 值，c 更新为 a + b 的值，同时 n 减 1 。当 n 不大于 2 时，循环结束并返回 c 的值，也就是斐波那契数列中第 n 个位置的数值。

在主函数 main 中，首先通过 scanf 函数获取用户输入的整数 n ，然后调用 Fib 函数计算斐波那契数列中第 n 个位置的数值，并将结果存储在 ret 变量中，最后使用 printf 函数输出结果。

 

例如，如果用户输入 5 ，那么函数 Fib 会经过以下计算过程：

 

• 第一次循环：a = 1，b = 1，c = 2，n = 4
• 第二次循环：a = 1，b = 2，c = 3，n = 3
• 第三次循环：a = 2，b = 3，c = 5，n = 2

 

循环结束，返回 5 。

 

又如，如果用户输入 8 ，计算过程会相应地增加更多次循环，最终返回斐波那契数列第 8 个位置的数值。

 

运行结果：

 

 

求第50个斐波那契数，这个结果算出来时间非常快，

这个第50个斐波那契数太大了，一个整型放不下，所以是负数。

 迭代的⽅式去实现这个代码，效率就要⾼出很多了。

总结：

有时候，递归虽好，但是也会引⼊⼀些问题，所以我们⼀定不要迷恋递归，适可⽽⽌就好。

有的同学会问，我们什么情况用迭代？什么时候用循环呢？ 这需要看需求

当⼀个问题⾮常复杂，难以使⽤迭代的⽅式实现时，

此时递归实现的简洁性便可以补偿它所带来的运⾏时开销。

 拓展学习：

学习《函数递归》这节课，我们其实可以用递归这么一个思想解决一些问题

• 青蛙跳台阶问题

• 汉诺塔问题

以上2个问题都可以使⽤递归解决，有兴趣同学们可以研究研究。欢迎在评论区发表你的想法

关于函数递归主要内容就讲到这里，希望对你的学习有用！

---

完~