函数递归与迭代图解

---

一、函数递归

1. 什么是递归？

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

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

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

2. 递归的两个必要条件

（1）存在限制条件，当满足这个限制条件的时候，递归便不再继续。

void print(unsigned int n)
{
	//if (n > 9) 没有条件时代码出现问题（栈溢出）
	{
		print(n / 10);
	}
	printf("%d ", n % 10);
}

（2）每次递归调用之后越来越接近这个限制条件。

3. 练习

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

#define _CRT_SECURE_NO_WARNINGS 1
#include

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

✨运行结果✨

分析：

编写函数，求字符串的长度。

#include

int my_strlen(char* s)
{
	int count = 0;
	while (*s != '\0')
	{
		count++;
		s++;
	}
	return count;
}

int main()
{
	//求字符串长度
	char arr[10] = "abc";
	//数组名arr是数组首元素的地址 - char*
	int len = my_strlen(arr);
	printf("%d\n", len);

	return 0;
}

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

#include

int my_strlen(char* s)//也可写成char s[]
{
	if (*s != '\0')
	{
		return 1 + my_strlen(s+1);//可写成++s,不可写成s++
	}
	else
	{
		return 0;
	}
}
int main()
{
	//求字符串长度
	char arr[10] = "abc";
	//数组名arr是数组首元素的地址 - char*
	int len = my_strlen(arr);
	printf("%d\n", len);

	return 0;
}

二、递归与迭代（循环）

1. 练习

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

#define _CRT_SECURE_NO_WARNINGS 1
#include

int Fac1(int n)   //方法一
{
	int i = 0;
	int ret = 1;
	for (i = 1; i <= n; i++)
	{
		ret *= i;
	}
	return ret;
}

int Fac2(int n)   //方法二
{
	if (n <= 1)
		return 1;
	else
		return n* Fac(n - 1);
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	//求n的阶乘
	int ret = Fac2(n);
	printf("%d\n", ret);

	return 0;
}

斐波那契函数

#define _CRT_SECURE_NO_WARNINGS 1
#include

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个斐波那契数字的时候特别耗费时间。
使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。

为什么呢？
我们发现 Fib 函数在调用的过程中很多计算其实在一直重复。

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

#define _CRT_SECURE_NO_WARNINGS 1
#include

int count = 0;//全局变量
int Fib(int n)
{
    if (n == 3)
        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("count = %d\n", count);

    return 0;
}

✨运行结果✨

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

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

那如何解决上述的问题：
（1）将递归改写成非递归。
（2）使用static对象替代nonstatic局部对象。在递归函数设计中，可以使用static对象替代nonstatic局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放nonstatic对象的开销，而且static对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。

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

//求n的阶乘
int factorial(int n)
{
    int result = 1;
    while (n > 1)
    {
        result *= n;
        n -= 1;
    }
    return result;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include

//迭代(循环)
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;
}

提示：

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

---

如有问题，欢迎批评指正呀！