初阶 《函数》 7. 函数递归

7. 函数递归

7.1 什么是递归？

程序调用自身的编程技巧称为递归（ recursion）。

递归作为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

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

7.2 递归的两个必要条件

存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件。

7.2.1 练习1

接受一个整型值（无符号），按照顺序打印它的每一位。
例如：
输入：1234，输出 1 2 3 4

#include <stdio.h>
//%d 是打印有符号的整数（会有正负数）
//%u 是打印无符号的整数
void print(unsigned int n)
{
	if (n > 9)//不加这一条件会栈溢出
	{
		print(n / 10);
	}
	printf("%d ", n % 10);
}
int main()
{
	unsigned int num = 0;
	scanf("%u", &num);
	print(num);
	return 0;
}

7.2.2 练习2

编写函数不允许创建临时变量，求字符串的长度

#include <stdio.h>
int my_strlen(char* str)
{
	if (*str != '\0')
	{
		return 1 + my_strlen(str + 1);
	}
	else
	{
		return 0;
	}
}
int main()
{
	char arr[] = "abc";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

7.3 递归与迭代

7.3.1 练习3

求n的阶乘（不考虑溢出）

递归

#include <stdio.h>
int fac(int n)
{
	if (n <= 1)
	{
		return 1;
	}
	else
	{
		return n * fac(n - 1);
	}
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = fac(n);
	printf("%d\n", ret);
	return 0;
}

7.3.2 练习4

求第n个斐波那契数（不考虑溢出）

递归

#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;
}

但是我们发现存在问题：

使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。
使用 fac 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。

为什么呢？

我们发现 fib 函数在调用的过程中很多计算其实在一直重复。

如果我们把代码修改一下：

#include <stdio.h>
int count = 0;
int Fib(int n)
{
	if (3 == n)
	{
		count++;
	}
	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);
	printf("%d\n", count);
	return 0;
}

最后我们输出看看count，是一个很大很大的值。

那我们如何改进呢？

在调试 fac 函数的时候，如果你的参数比较大，那就会报错：stack overflow（栈溢出）这样的信息。
系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者死递归，这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。

比如，下面代码就采用了，非递归的方式来实现：

迭代

//求n的阶乘
#include <stdio.h>
int fac(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 = fac(n);
	printf("ret=%d\n", ret);
	return 0;
}

迭代

//求第n个斐波那契数
#include <stdio.h>
int Fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 0;
	while (n >= 3)
	{
		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;
}

提示

1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。

函数递归的几个经典题目（自主研究）：

1. 汉诺塔问题
2. 青蛙跳台阶问题