C语言：函数递归

                                                    创作不易，给个三连吧！！

一、什么是递归

递归式一种解决问题的方法，在C语言中，递归就是自己调用自己。

递归的思想： 把⼀个⼤型复杂问题层层转化为⼀个与原问题相似，但规模较小的⼦问题来求解；直到⼦问题不能再被拆分，递归就结束了。所以递归的思考⽅式就是把⼤事化小的过程。

递归中的递就是递推的意思，归就是回归的意思

  1. int main()
  2. {
  3.  printf("hehe\n");
  4.  main();//main函数中⼜调⽤了main函数
  5.  return 0;
  6. }

以上就是一个简答的递归程序（自己调用自己），但是最后代码会陷入死递归，导致栈溢出（stack overflow）

所以递归必须要有自己的限制条件！而不能无限制地递归

二、递归的限制条件

为了防止死递归，有2个必要条件：

1、递归存在限制条件，当满足这个条件的时候，递归便不再继续（也就是说，我们要设置让递归停止下来的条件）

2、每次递归的调用要越来越接近这个限制条件（要慢慢让递归停下来）

三、递归的举例

3.1 求n的阶乘

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

这样的思路就是把⼀个较⼤的问题，转换为⼀个与原问题相似，但规模较⼩的问题来求解的。

n!---> n*(n-1)! (n-1)! ---> (n-1)*(n-2)!.... 直到n是1或者0时，不再拆解

再稍微分析⼀下，当 n<=1 的时候，n的阶乘是1，其余n的阶乘都是可以通过上述公式计算。

n的阶乘的递归公式如下：

  1. Fact(int n)
  2. {
  3. 	if (n <= 0)
  4. 		return 1;
  5. 	else
  6. 		return n * Fact(n - 1);
  7. }
  8. int main()
  9. {
  10. 	int n = 0;
  11. 	scanf("%d", &n);
  12. 	int ret=Fact(n);
  13. 	printf("%d", ret);
  14. 	return 0;
  15. }

3.2 按顺序打印一个整数的每一位

        1234%10就能得到4，然后1234/10得到123，这就相当于去掉了4 然后继续对123%10，就得到了3，再除10去掉3，以此类推 不断的 %10 和 \10 操作，直到1234的每⼀位都得到； 但是这⾥有个问题就是得到的数字顺序是倒着的，我们以这个思路设想一个Print函数

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

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

  1. void Print(int n)
  2. {
  3.  if(n>9)
  4.  {
  5.  Print(n/10);
  6.  }
  7.  printf("%d ", n%10);
  8. }
  9. int main()
  10. {
  11.  int m = 0;
  12.  scanf("%d", &m);
  13.  Print(m);
  14.  return 0;
  15. }

3.3 斐波那契数列

第1个数和第2个数是1，从第3个数开始，后面每个数都是前两个数之和，所以当n大于2时，有Fib（n）=Fib（n-1）+Fib（n-2）

  1. int Fib(int n)
  2. {
  3.  if(n<=2)
  4.  return 1;
  5.  else
  6.  return Fib(n-1)+Fib(n-2);
  7. }
  8. int main()
  9. {
  10.  int n = 0;
  11.  scanf("%d", &n);
  12. int ret = Fib(n);
  13.  printf("%d\n", ret); 
  14.  return 0;
  15. }

四、迭代

迭代，通常就是循环的方式

4.1 求n的阶乘

  1. Fact(int n)
  2. {
  3. 	int ret = 1;
  4. 	for (int i = 1; i <= n; i++)
  5. 		ret *= i;
  6. 	return ret;
  7. }
  8. int main()
  9. {
  10. 	int n = 0;
  11. 		scanf("%d", &n);
  12. 		int ret=Fact(n);
  13. 		printf("%d", ret);
  14. 		return 0;
  15. }

4.2 斐波那契数列

  1. Fib(int n)
  2. {
  3. 	int a = 1;
  4. 	int b = 1;
  5. 	int c = 1;
  6. 	while (n >= 3)
  7. 	{
  8. 		c = a + b;
  9. 		a = b;
  10. 		b = c;
  11. 		n--;
  12. 	}
  13. 	return c;
  14. }
  15. int main()
  16. {
  17. 	int n = 0;
  18. 		scanf("%d", &n);
  19. 		int ret=Fib(n);
  20. 		printf("%d", ret);
  21. 		return 0;
  22. }

五、递归与迭代的选择

       递归函数在有些时候是可以产生争取的结果，并且往往几行代码就可以完成大量的运算，但是在递归函数调用的过程中也会存在一些运行的开销。

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

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

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

     事实上，我们看到的许多问题是以递归的形式进⾏解释的，这只是因为它⽐⾮递归的形式更加清晰， 但是这些问题的迭代实现往往⽐递归实现效率更⾼。

      比如斐波那契数列，当我们使用递归的方法就解决时，如果输入50，需要很长的时间才能算出结果，因为递归程序会不断展开，在展开的过程中会有很多次的重复计算，而且递归层次越深，冗余计算就会越来越多。

  1. #include 
  2. int count = 0;
  3. int Fib(int n)
  4. {
  5.  if(n == 3)
  6.  count++;//统计第3个斐波那契数被计算的次数
  7.  if(n<=2)
  8.  return 1;
  9.  else
  10.  return Fib(n-1)+Fib(n-2);
  11. }
  12. int main()
  13. {
  14.  int n = 0;
  15.  scanf("%d", &n);
  16.  int ret = Fib(n);
  17.  printf("%d\n", ret); 
  18.  printf("\ncount = %d\n", count);
  19.  return 0;
  20. }

 输入40   输出39088169    

      在计算第40个斐波那契数的时候，使⽤递归⽅式，第3个斐波那契数就被重复计算了 39088169次，这些计算是⾮常冗余的。所以斐波那契数的计算，使⽤递归是⾮常不明智的，所以迭代的效率会更优！！

     而当⼀个问题⾮常复杂，难以使⽤迭代的⽅式实现时，此时递归实现的简洁性便可以补偿它所带来的运⾏时开销。

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

六、递归拓展问题

6.1 青蛙跳台阶问题

一个青蛙，一次只能跳一个台阶或者两个台阶，求跳n个台阶有几种跳法？？

分析：

n=1,跳1次一个台阶，即jump(1)=1

n=2,可以跳2次一个台阶，也可以直接跳两个太极，即jump(2)=2

n=3，可以跳3次一个台阶，或者先跳1个台阶再跳2个台阶，或者先跳2个台阶再跳1个台阶，即jump（3）=3

n=4，可以 1111  22 2111 1211 1121 1112 即jump（4）=6

……

我们发现，当jump（3）时，如果第一次跳了1个台阶，剩下2个台阶的跳法相当于jump（2），如果第一个跳了2个台阶，剩下1个台阶的跳法相当于jump（1）

所以我们可以得到jump（3）=jump（1）+jump（2）

即jump（n）=jump（n-1）+jump（n-2）

递归：

  1. jump(int n)
  2. {
  3.     assert(N>=0);
  4. 	if (n <= 2)
  5. 		return n;
  6. 	else
  7. 		return jump(n - 1) + jump(n - 2);
  8. }
  9. int main()
  10. {
  11. 	int n = 0;
  12. 		scanf("%d", &n);
  13. 		int ret=jump(n);
  14. 		printf("%d", ret);
  15. 		return 0;
  16. }

迭代：

  1. jump(int n)
  2. {
  3.     assert(n>=0);
  4. 	int a = 1;
  5. 	int b = 2;
  6. 	int c = 0;
  7. 	if (n <= 2)
  8. 		return n;
  9. 	else
  10. 	{
  11. 		for (int i = 3; i <= n; i++)
  12. 		{
  13. 			c = a + b;
  14. 			a = b;
  15. 			b = c;
  16. 		}
  17. 		return c;
  18. 	}
  19. }
  20. int main()
  21. {
  22. 	int n = 0;
  23. 	scanf("%d", &n);
  24. 	int ret = jump(n);
  25. 	printf("%d", ret);
  26. 	return 0;
  27. }

6.2 汉诺塔问题

      简单的理解就是有三根柱子，其中一根柱子上有n个由上到下逐渐增大的圆盘，我们需要在保证圆盘始终是大圆盘在下，小圆盘在上的情况下每次移动一个圆盘，直到完成所有圆盘的移动。如图所示，要探究将n个圆盘从A挪动到C挪动的过程，以及挪动顺序

分析：

1个圆盘：A->C                   共1次

2个圆盘：A->B

                A->C

                 B->C                   共3次

3个圆盘    A->C

                 A->B

                 C->B

                 A->C

                 B->A

                 B->C

                 A->C                       共7次

我们发现，最中间的次数恰好就是A->C即最大的圆盘移到C上，中间次数之前相当于将最大圆盘之上的n-1个圆盘放到辅助柱子B上，而中间次数之和的次数相当于将辅助B之上的n-1个圆盘放回C上，所以我们可以得到公式挪动次数：F（n）=F（n-1）+1+F（n-1）即F（n）=F（n-1）*2+1

  1. F(int n)
  2. {
  3. 	assert(n>=0);
  4. 	if (n==0)
  5. 		return 0;
  6. 	else
  7. 		return 2*F(n - 1)+1;
  8. }

而挪动的过程我们封装2个函数

  1. void Move(char a, char b, int n)
  2. {
  3. 	//n代表第几个圆盘，a和b穿得是柱子的编号，表示从a柱子挪到b柱子
  4. 	printf("第%d个圆盘从%c柱挪动到%c柱\n", n, a, b);
  5. }
  6. void Hanoi(char a, char b, char c, int n)
  7. //a表示圆盘所在的柱子，b表示移动圆盘的辅助柱子，c表示圆盘的目标柱子，n表示圆盘的个数
  8. {
  9. 	assert(n >= 0);
  10. 	if (n ==1)
  11. 		Move(a, c, n);//直接将圆盘放到c上
  12. 	else
  13. 	{
  14. 		Hanoi(a, c, b, n - 1);//将前面n-1个圆盘通过C先挪动到B上
  15. 		Move(a, c, n);//将第n个圆盘放到c上
  16. 		Hanoi(b, a, c, n - 1);//将b上的n-1个圆盘通过a挪动到c上
  17. 	}
  18. }

最后通过这三个函数完成计算汉诺塔问题的挪动次数以及挪动的过程！！

  1. F(int n)//计算挪动次数
  2. {
  3. 	assert(n>=0);
  4. 	if (n==0)
  5. 		return 0;
  6. 	else
  7. 		return 2*F(n - 1)+1;
  8. }
  9. void Move(char a, char b, int n)
  10. {
  11. 	//n代表第几个圆盘，a和b穿得是柱子的编号，表示从a柱子挪到b柱子
  12. 	printf("第%d个圆盘从%c柱挪动到%c柱\n", n, a, b);
  13. }
  14. void Hanoi(char a, char b, char c, int n)
  15. //a表示圆盘所在的柱子，b表示移动圆盘的辅助柱子，c表示圆盘的目标柱子，n表示圆盘的个数
  16. {
  17. 	assert(n > 0);
  18. 	if (n == 1)
  19. 		Move(a, c, n);//将圆盘直接移动到c上
  20. 	else
  21. 	{
  22. 		Hanoi(a, c, b, n - 1);//将前面n-1个圆盘通过C先挪动到B上
  23. 		Move(a, c, n);//将第n个圆盘放到c上
  24. 		Hanoi(b, a, c, n - 1);//将b上的n-1个圆盘通过a挪动到c上
  25. 	}
  26. }
  27. int main()
  28. {
  29. 	int n = 0;
  30. 	scanf("%d", &n);//输入圆盘数量
  31. 	char src = 'A';//a代表圆盘所在的柱子
  32. 	char ass = 'B';//b代表a->c的辅助柱子
  33. 	char dst = 'C';//c代表圆盘的目标柱子
  34. 	printf("挪动过程如下：\n");
  35. 	Hanoi(src,ass,dst, n);//挪动过程
  36. 	printf("挪动次数为%d次", F(n));//挪动次数
  37. 	return 0;
  38. }

 

6.3 求1-n的全排列

      比如1、2、3、4、5，为了实现全排列，我们先将他放在一个数组中，我们先取第1个数，如果第1个数确定为2，那么第1个数是2的全排列就即为1345的全排列，第2个数可以取1345中的1个数，又可以等价于后三个数的全排列，以此类推……

因此，n个数的全排列=确定的第一位+（n-1）个数全排列=确定的前两位+（n-2）个数全排列=............

其中，确定某位是某数这一操作由——与后面的数依次交换-递归-换回——实现。

  1. int count = 0;//利用全局变量计算总次数
  2. void swap(int arr[], int a, int b)//交换下标为a  b的两个数
  3. {
  4. 	int temp = arr[a];
  5. 	arr[a] = arr[b];
  6. 	arr[b] = temp;
  7. }
  8. void Perm(int arr[], int begin, int n)//n为最后一个数的角标，begin为数组从下标为几的数字开始
  9. {
  10. 	assert(n > 0);
  11. 	if (begin == n)
  12. 	{	//如果begin为最后一个元素开始，说明该层递归已经结束了,此次数组的顺序就是全排列的顺序
  13. 		for (int i = 0; i < n; i++)
  14. 			printf("%d-", arr[i]);
  15. 		printf("%d\n", arr[n]);
  16. 		count++;//利用全局变量计算总次数
  17. 	}
  18. 	else//如果begin还在前面，就要将begin与后面的数一次交换然后递归，每次递归完要回溯
  19. 	{
  20. 		for (int k = begin; k <= n; k++)
  21. 		{
  22. 			//begin与后面的数依次交换
  23. 			swap(arr, begin, k);
  24. 			//问题变成begin与后面的数进行全排列
  25. 			Perm(arr, begin + 1, n);
  26. 			//回溯
  27. 			swap(arr, begin, k);
  28. 		}
  29. 	}
  30. }
  31. int main()
  32. {
  33. 	int* arr;
  34. 	int n;
  35. 	printf("请输入n:");
  36. 	scanf("%d", &n);
  37. 	arr = (int*)malloc(n*sizeof(int));
  38.     //创建数组
  39. 	for (int i = 0; i < n; i++)
  40. 		arr[i] = i + 1;
  41. 	Perm(arr, 0, n - 1);//开始进行全排列
  42. 	printf("一共有%d种排列方式", count);
  43. }

 

注：本文转载自blog.csdn.net的✿ ༺小陈在拼命༻✿的文章"https://blog.csdn.net/weixin_51142926/article/details/136068475"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！