【C递归和迭代】兔子繁殖问题、青蛙跳台阶问题和汉诺塔问题

已于 2023-01-17 15:51:23 修改
阅读量886 收藏 19
点赞数 19
分类专栏： C语言初阶 文章标签： c语言 算法 c++ 数据结构 开发语言
于 2022-12-30 23:00:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70088010/article/details/128479549
版权

⭐博客主页：️CS semi主页
⭐欢迎关注：点赞收藏+留言
⭐系列专栏：C语言初阶
⭐代码仓库：C Advanced
家人们更新不易，你们的点赞和关注对我而言十分重要，友友们麻烦多多点赞＋关注，你们的支持是我创作最大的动力，欢迎友友们私信提问，家人们不要忘记点赞收藏＋关注哦！！！

【C递归】

前言

汉诺塔问题和青蛙跳台阶问题是C语言函数递归中很重要的两个问题，我们既可以用递归的方式进行编译，也可以用迭代的方法进行编译。一提到递归大家可能会觉得好难，可是真有那么难吗，以下两道经典的递归题目让大家完全了解递归。

一、兔子繁殖问题

（一）题目描述

在解决下面两个问题之前，我们先来看一个比较经典的问题，就是兔子繁殖问题，即我们常说的斐波那契数列，这个问题是怎么编译的呢？我们可以先查一查兔子是如何繁殖的？
题目描述：一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔子都不死，那么一年以后可以繁殖多少对兔子？
题目说的是在两个月后才能繁殖，我们拿一对幼兔做实验，前两个月是只有一对成年兔子的，如下图：
在这里插入图片描述

（二）解题

1.递归做法

（1）成兔
（i）分析

先看成年兔子：
我们列出来了12个月，一年成年兔子的总对数，我们发现其排列的是0 1 1 2 3 5 8 13 21 34 55 89 144，这似乎看不出什么规律来，那我们画个图吧！

在这里插入图片描述
大家要仔细想想，这怎么后一个月的成兔等于前两个月的成兔之和。我们拿前四个月的兔子进行比较，如图：
在这里插入图片描述
成兔的个数是原本已经成年的加一下上上次所繁殖的幼兔此时成年的新成兔，由于一对成兔只能生一对，那也就是上上次的成兔加上上次的成兔，如下图，给出公式：
在这里插入图片描述
那我们就用递归函数来写一下吧！！！

（ii）代码
#include<stdio.h>

int fib(int n) {
	if (n == 0) {
		return 0;
	}
	else if ((n == 1) || (n == 2)) {
		return 1;
	}
	else { //n>2
		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;
}
（iii）代码分析

在这里插入图片描述
如上图进行递归。

（2）幼兔
（i）分析

大家可能觉得幼兔很难算，可是大家一想，幼兔是之前成兔繁殖的新幼兔，而成兔是怎么来的，成兔是本已经成年的加一下上上次所繁殖的幼兔此时成年的新成兔，也就是上上次的成兔加上上次的成兔，那幼兔可想而知那不就是上一个月的成兔个数嘛！！！这不就是一个递归嘛，还是上上个月的幼兔加上上个月幼兔。是不是很奇妙，那我们开始写代码吧！

（ii）代码
#include<stdio.h>

int fib1(int n) {
	if (n == 0) {
		return 1;
	}
	else if (n == 1) {
		return 0;
	}
	else if (n == 2) {
		return 1;
	}
	else { //n>2
		return fib1(n - 1) + fib1(n - 2);
	}
}

int main() {
	int n = 0;
	scanf("%d", &n);
	int ret1 = fib1(n);
	printf("%d\n", ret1);
	
	return 0;
}
（iii）代码分析

在这里插入图片描述

（3）总的兔子个数
（i）分析

既然是总的兔子个数，那就很简单了，是本月的幼兔加上成兔，那不就是那两串代码合起来吗？那我们来试一试吧！

（ii）代码
#include<stdio.h>

//成兔
int fib(int n) {
	if (n == 0) {
		return 0;
	}
	else if ((n == 1) || (n == 2)) {
		return 1;
	}
	else { //n>2
		return fib(n - 1) + fib(n - 2);
	}
}

//幼兔
int fib1(int n) {
	if (n == 0) {
		return 1;
	}
	else if (n == 1) {
		return 0;
	}
	else if (n == 2) {
		return 1;
	}
	else { n>2
		return fib1(n - 1) + fib1(n - 2);
	}
}

int main() {
	int n = 0;
	scanf("%d", &n);
	int ret = fib(n);
	int ret1 = fib1(n);
	printf("成兔=%d\n", ret);
	printf("幼兔=%d\n", ret1);
	int ret2 = ret + ret1;
	printf("总数=%d\n", ret2);
	
	return 0;
}

运行代码截图：

在这里插入图片描述

（iii）分析

此外，大家发现了吗？这个总数居然也是个斐波那契数列，大家可以仔细想想，本月的总的兔子数是上个月成兔生的同等数列的幼兔加上上个月的成兔再加一下上上个月生的同样数量的幼兔本月成年，那不就是上个两份的上个月成兔加上上个月的幼兔，我们发现，本月的兔子总数岂不是下个月的成兔数量吗，为什么呢？因为下个月的成兔是本月成兔的数量加上本月幼兔在下个月成熟的数量，哦~原来如此，这总数岂不是就是成兔的斐波那契数列往前推一位吗？那不也是一个斐波那契吗？
那我们试试写代码吧！

（iv）代码
#include<stdio.h>

//成兔
int fib(int n) {
	if (n == 0) {
		return 0;
	}
	else if ((n == 1) || (n == 2)) {
		return 1;
	}
	else {  //n>2
		return fib(n - 1) + fib(n - 2);
	}
}

//幼兔
int fib1(int n) {
	if (n == 0) {
		return 1;
	}
	else if (n == 1) {
		return 0;
	}
	else if (n == 2) {
		return 1;
	}
	else { //n>2
		return fib1(n - 1) + fib1(n - 2);
	}
}

//总数
int fib2(int n) {
	if (n == 0) {
		return 1;
	}
	else if (n == 1) {
		return 1;
	}
	else {
		return fib2(n - 1) + fib2(n - 2);
	}
}

int main() {
	int n = 0;
	scanf("%d", &n);
	int ret = fib(n);
	int ret1 = fib1(n);
	printf("成兔=%d\n", ret);
	printf("幼兔=%d\n", ret1);
	int ret2 = fib2(n);
	printf("总数=%d\n", ret2);
	
	return 0;
}

在这里插入图片描述

2.迭代做法

（1）成兔
（i）分析

思路具体和递归做法一样，但不同的点是做法，我们思考一下，a,b为第一个月和第二个月的成兔数量，第三个月成兔数量c=a+b，我们继续往下看，第四个月成兔数量为d=b+c=b+a+b，第五个月成兔数量为e=c+d=c+b+c=a+b+b+a+b，大家有发现什么奇特的地方吗，如果我们把c的值赋给b，把b的值赋给a，用已经算得的结果赋给前面的值再进行相加求出后面的结果。如下图：
在这里插入图片描述

（ii）代码
#include<stdio.h>

//成兔对数
int fib(int n) {
	if (n == 0) { 
		return 0;
	}
	else if (n == 1 || n == 2) {
		return 1;
	}
	else {//n>2
		int a = 1;//第一个月
		int b = 1;//第二个月
		int c = 0;//第三个月
		//a,b分别为前两项，c为前两项的和，得到c的值后更新a,b的值
		while (n > 2) {//更新a,b
			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;
}
（2）幼兔
（i）分析

幼兔的思路和成兔的思路一样的，我们既可以用第0个月来作为a，也可以用第1个月来作为a进行计算。

（ii）代码
#include<stdio.h>

//幼兔对数
int fib1(int n) {
	if (n == 0) {
		return 1;
	}
	else if (n == 1) {
		return 0;
	}
	else if (n == 2) {
		return 1;
	}
	else {//n>2
		int a = 0;//第一个月
		int b = 1;//第二个月
		int c = 0;//第三个月
		//a,b为前两项，c为前两项的和，得到的c用以更新a,b的值
		while (n > 2) {//更新a,b的值
			c = a + b;
			a = b;
			b = c;
			n--;
		}
		return c;
	}
}

int main() {
	int n = 0;
	scanf("%d", &n);
	int ret1 = fib1(n);
	printf("幼兔=%d\n", ret1);

	return 0;
}
（3）总数
（i）分析

总数这里就有两种做法，一种是幼兔加成兔；另一种是再利用迭代的思想，只不过这次前面的a,b的值要发生变化。

（ii）代码
//相加
#include<stdio.h>

//成兔对数
int fib(int n) {
	if (n == 0) {
		return 0;
	}
	else if (n == 1 || n == 2) {
		return 1;
	}
	else {//n>2
		int a = 1;//第一个月
		int b = 1;//第二个月
		int c = 0;//第三个月
		//a,b分别为前两项，c为前两项的和，得到c的值后更新a,b的值
		while (n > 2) {//更新a,b
			c = a + b;
			a = b;
			b = c;
			n--;
		}
		return c;
	}
}

//幼兔对数
int fib1(int n) {
	if (n == 0) {
		return 1;
	}
	else if (n == 1) {
		return 0;
	}
	else if (n == 2) {
		return 1;
	}
	else {//n>2
		int a = 0;//第一个月
		int b = 1;//第二个月
		int c = 0;//第三个月
		//a,b为前两项，c为前两项的和，得到的c用以更新a,b的值
		while (n > 2) {//更新a,b的值
			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);
	int ret1 = fib1(n);
	printf("幼兔=%d\n", ret1);
	int ret2 = ret + ret1;
	printf("总数=%d\n", ret2);

	return 0;
}

//迭代思想
#include<stdio.h>

//成兔对数
int fib(int n) {
	if (n == 0) { 
		return 0;
	}
	else if (n == 1 || n == 2) {
		return 1;
	}
	else {//n>2
		int a = 1;//第一个月
		int b = 1;//第二个月
		int c = 0;//第三个月
		//a,b分别为前两项，c为前两项的和，得到c的值后更新a,b的值
		while (n > 2) {//更新a,b
			c = a + b;
			a = b;
			b = c;
			n--;
		}
		return c;
	}
}

//幼兔对数
int fib1(int n) {
	if (n == 0) {
		return 1;
	}
	else if (n == 1) {
		return 0;
	}
	else if (n == 2) {
		return 1;
	}
	else {//n>2
		int a = 0;//第一个月
		int b = 1;//第二个月
		int c = 0;//第三个月
		//a,b为前两项，c为前两项的和，得到的c用以更新a,b的值
		while (n > 2) {//更新a,b的值
			c = a + b;
			a = b;
			b = c;
			n--;
		}
		return c;
	}
}

//总数
int fib2(int n) {
	if (n == 0) {
		return 1;
	}
	else if (n == 1) {
		return 1;
	}
	else {
		int a = 1;//第0个月
		int b = 1;//第1个月
		//a,b为前两项，c为前两项的和，得到的c用以更新a,b的值
		int c = 0;//第2个月
		while (n > 1) {//更新a,b的值
			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);
	int ret1 = fib1(n);
	printf("幼兔=%d\n", ret1);
	int ret2 = fib2(n);
	printf("总数=%d\n", ret2);

	return 0;
}

解决了兔子繁殖的问题，那我们继续看一下青蛙跳台阶的问题！

二、青蛙跳台阶问题

（一）前言

在解决这个问题之前，我想吐槽一下在大一上学期进入实验室的纳新题，大家看一下下面的图：
在这里插入图片描述
出题目的人是比较喜欢玩LOL的自由天使呀！让人抓不住头脑，在网上搜了半天没查出来，到今天我再看一看这个题目的时候，也是被自己之前笑到了，这些题目果然只需要把知识点揪出来就可以做了，不用理会主人公什么操作什么的，那接下来我们看一看吧！

（二）题目描述

有一只青蛙，它碰到一个楼梯挡了它的路，它需要越过这个楼梯，可是受于楼梯高度，它一次只能选择跳一个台阶或者两个台阶，那它跳过这段台阶有多少次方式呢？

（三）解题

这个题目看起来很难，如果用穷举法，一个台阶一个跳法，两个台阶两种跳法，三个台阶三种跳法，四个台阶五个跳法，五个台阶8个跳法……我的天哪，这不是越来越多了吗，穷举法找不出通项来啊！那我们重新想一想，画个图试一试：

1.递归做法

（1）分析

先来一张图片看一看：
在这里插入图片描述
我们看：
1个台阶：只需要跳一个台阶。
2个台阶：选择一个一个跳和一次跳两个。
3个台阶：1、先跳一个台阶，分出两条路一个一个跳，直接跳两个台阶2.先跳两个，再跳一个台阶。 即：先跳了一个，则还剩两个，就是跳两个的情况；先跳了两个，则还剩一个，就是跳一个台阶的情况。 所以跳三个=跳一个+跳两个
4个台阶：1.先跳一个台阶，再分出三条路，一个一个跳，先跳一个再跳两个，先跳两个再跳一个。2.先跳两个，分出两条路，一个一个跳，直接跳两个。 即：先跳了一个，则还剩三个，就是跳三个的情况；先跳了两个，则还剩两个，就是跳两个的情况。 所以跳四个=跳两个+跳三个。
……
大家有没有看到，这不就是斐波那契数列嘛，青蛙肯定是先选择跳一个和两个的情况，后面的情况根据递归能进行解决，就是前两次之和。那我们来写一下代码吧！

（2）代码
#include<stdio.h>

int fib(int n) {
	if (n == 1) {
		return 1;
	}
	else if (n == 2) {
		return 2;
	}
	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;
}

至于为何是把1和2单拎出来，原因是大家可以想青蛙跳一次无非是使剩余台阶-1或者-2，且可以知道最终都会回到剩余1个或两个台阶的情况，因此我们是可以根据这两个情况即fib(1)=1和fib(2)=2以基准来进行递归的。

（3）代码分析

在这里插入图片描述

2.迭代做法

（1）分析

迭代做法和前面的一样，只要前面的看懂了，这里的问题就会迎刃而解。

（2）代码
#include<stdio.h>

int fib(int n) {
	if (n == 1) {
		return 1;
	}
	else if (n == 2) {
		return 2;
	}
	else {
		int a = 1;//跳一个台阶
		int b = 2;//跳两个台阶
		int c = 0;
		//c为前两项之和，更新a,b的值以达到迭代目的
		while (n > 2) {//更新a,b的值
			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;
}
（3）代码分析

在这里插入图片描述

三、汉诺塔问题

（一）题目概述

相传在古印度圣庙中，有一种被称为汉诺塔(Hanoi)的游戏。该游戏是在一块铜板装置上，有三根杆(编号A、B、C)，在A杆自下而上、由大到小按顺序放置64个金盘。游戏的目标：把A杆上的金盘全部移到C杆上，并仍保持原有顺序叠好。操作规则：每次只能移动一个盘子，并且在移动过程中三根杆上都始终保持大盘在下，小盘在上，操作过程中盘子可以置于A、B、C任一杆上。

在这里插入图片描述

（二）思路及解题步骤

一个盘子：移动一个盘子到C柱子。
两个盘子：1->B，2->C，1->C。
三个盘子：1->C，2->B，1->B，3->C，1->A，2->C，3->C。
四个盘子：1->B，2->C，1->C，3->B，1->A，2->B，1->B，4->C，1->C，2->A，1->A，3->C，1->B，2->C，1->C。
……
在这个操作过程当中，大家有没有发现一个很有趣的现象，当盘子是三个的时候，是先在三个柱子分布的是1，2，0的圆盘个数，也就是说，先排好了两个，再去排底下那个最大的圆盘。在排四个圆盘的时候，我们发现排到第一步的时候是先排到三根柱子的数量为：2，2，0。再继续排，排到第二步的时候发现三根柱子的个数为：1，3，0。不知道大家发现了没有，当我们排的时候，是先要排完n-1个圆盘再去排最后一个，而n-1个圆盘是怎么排的呢？那就是先排好n-2个圆盘再去排第n-1个圆盘。是不是很神奇，那我们

以三个圆盘为例：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

（三）代码

#include<stdio.h>

//思路：先借助C柱子移动到B柱子，
//再把A柱子最后一个大圆盘移动到C柱子上，
//最后再借助A柱子将B柱子内的圆盘移动到C柱子上
//Hanoi(从哪根柱子，借助哪根柱子，移动到哪根柱子，盘子数量)
int i = 0;//使用一个全局变量统计次数
void move(char x, char y, int n){
	printf("把第%d个圆盘从%c柱->%c柱\n", n, x, y);
	i++;
}

void Hanoi(char A, char B, char C, int n){
	if (n == 1){
		//调用1次move
		move(A, C, n);
	}
	else{
		//先将n-1个圆盘从A柱借助C柱移动到B柱上
		Hanoi(A, C, B, n - 1);
		//再将A柱子最后一个圆盘移动到C柱上
		move(A, C, n);
		//最后将n-1个圆盘从B柱借助A柱移动到C柱上
		Hanoi(B, A, C, n - 1);
	}
}

int main(){
	int n = 0;
	printf("请输入首先在A柱子上的圆盘个数:>");
	scanf("%d", &n);

	//将n个圆盘从A柱借助于B柱移动到C柱上
	Hanoi('A', 'B', 'C', n);
	printf("次数总共为：%d次\n", i);
	return 0;
}

（四）解题思路

这个递归解题有点复杂，先来个n=2的预热一下，再来个n=3的深层理解一下。
在这里插入图片描述

在这里插入图片描述

总结

递归的逻辑是很复杂的，是有缺陷的，但递归是一个很好的解题思路，可以锻炼自己的代码能力，我们今天学习到了这三个问题，相信大家肯定能很好的掌握递归与迭代的问题！！！

客官，码字不易，给个三连支持一下吧！！！

2022horse
关注
  • 19
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 31
    评论
专栏目录
函数递归调用-汉诺塔问题_c++实现汉诺塔问题_
09-28
汉诺塔问题是一个经典的计算机科学问题，源自印度的古老传说，它涉及到将一系列盘子从一根柱子移动到另一根柱子，遵循特定的规则。...不过，在理解和解决汉诺塔这样的问题时，递归提供了一种简洁而直观的解决方案。
兔子繁衍问题
weixin_45612871的博客
05-27 689
学习目标： 问题描述 有一对兔子，从出生后的第3个月起每个月都生一堆兔子。小兔子长到第三个月后每个月又生一对兔子，假设所有的兔子都不死，问30个月内每个月的兔子总数为多少？ 2.问题分析 3、算法设计 该题目是典型的迭代循环 公式展示 fibn=fibn−1+fibn−2(n>=3).迭代公式 fib_n=fib_n-_1+fib_n-_2(n>=3).迭代公式 fibn​=fibn​−1​+fibn​−2​(n>=3).迭代公式 fib=fib2=1(n=1,2).初值 fib
1055 : 兔子繁殖问题（c语言）
qq_35457789的博客
06-04 2487
这是一个有趣的古典数学问题，著名意大利数学家Fibonacci曾提出一个问题：有一对兔子，从出生后第3个月起每个月都生一对兔子。小兔子长到第3个月后每个月又生一对兔子。按此规律，假设没有兔子死亡，第一个月有一对刚出生的小兔子，问第n个月有多少对兔子？”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……科普：斐波那契数列（Fibonacci sequence），又称黄金分割数列，因数学家莱昂纳多·输入月数n（1
【兔子繁殖问题——C语言详解】
qq_73900397的博客
08-02 4802
兔子繁殖问题
C语言 兔子繁殖问题与斐波那契数列
2301_76445610的博客
08-04 1281
兔子繁殖问题：假定一对大兔子每月能生一对小兔子，且每对新生的小兔子经过一个月可以长成一对大兔子,具备繁殖能力，如果不发生死亡，且每次均生下一雌一雄，问一年后共有多少对兔子？（采用函数递归解决问题）
PHP递归实现汉诺塔问题的方法示例
10-18
主要介绍了PHP递归实现汉诺塔问题的方法,简单描述了汉诺塔问题,并结合实例形式分析了php基于递归算法解决汉诺塔问题的相关操作技巧,需要的朋友可以参考下
C++基于递归算法解决汉诺塔问题与树的遍历功能示例
08-28
"C++基于递归算法解决汉诺塔问题与树的遍历功能示例" 本文主要介绍了C++基于递归算法解决汉诺塔问题与树的遍历功能，简单描述了递归算法的原理，并结合实例形式分析了基于递归算法解决汉诺塔问题与树的遍历相关操作...
C语言-汉诺塔问题解决源码.zip
11-17
在C语言中解决汉诺塔问题通常使用递归算法。以下是`demo09.c`可能的实现方式： ```c #include void hanoi(int n, char from_rod, char inter_rod, char to_rod) { if (n >= 1) { // Step 1: Move n - 1 disks ...
兔子繁衍问题—c语言
iup321的博客
04-05 2248
一对兔子，从出生后第三个月起每个月都生一对兔子。小兔子长到第三个月后每个月又生一对兔子。假如兔子都不死，请问第一个月出生的一对兔子，至少需要繁衍到第几个月时兔子总数才能到达n对？输入一个不超过10 000的正整数n，输出兔子总数达到n的最少月数，试编写相应程序。printf("第%d个月的兔子的个数是%d\n",month,amount);printf("达到%d只兔子需要%d个月\n",amount,a);printf("达到这样的兔子数是1月和2月\n");printf("请输入兔子数：\n");
C语言每日一练——兔子繁殖问题 斐波那契数列
batter_的博客
07-12 1082
c语言 斐波那契数列 兔子繁殖问题
兔子繁殖问题采用递归和循环两种方式
chenkaibsw的专栏
03-11 1万+
兔子繁殖问题：题目描述有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？输入描述:输入int型表示month输出描述:输出兔子总数int型基本思路：这是一个递归问题，从第一个月开始每个月兔子的数目为:1,1,2,3,5,8,13........，可以看出从第三个月开始，每个月兔子的数目是前两个月兔子的数目的和，用数学...
递归——兔子繁殖问题
gml1997的博客
03-25 8363
兔子繁殖问题：题目描述 有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？ 输入描述: 输入int型表示month 输出描述: 输出兔子总数int型 基本思路： 这是一个递归问题，从第一个月开始每个月兔子的数目为:1,1,2,3,5,8,13…，可以看出从第三个月开始，每个月兔子的数目是前两个月兔子的数目的...
求解汉诺塔问题(提示, 使用递归)
helloword233的博客
09-19 5891
package com.test; import java.util.Scanner; public class Test { //主方法 public static void main(String[] args){ Scanner in = new Scanner(System.in); System.out.println("请输入汉诺塔的层数:"...
Python基础——递归及其经典例题（阶乘、斐波那契数列、汉诺塔）
薛定谔的猫的博客
06-24 7998
Python中的递归问题，包括阶乘、斐波那契数列和汉诺塔问题
【LeetCode】递归精选8题——基础递归、链表递归
Qiuhan_909的博客
02-20 1273
LeetCode 递归精选8题（包含基础递归、链表递归） 详解
递归与迭代 C语言练习题
LBP09的博客
10-29 1138
递归与迭代 C语言练习题 目录递归与迭代 C语言练习题1. 斐波那契数列 1 1 2 3 5 8 13 21 34 即F(n)+F(n+1)=F(n+2)2. 汉诺塔移动次数问题（忽略0）3. 青蛙上台阶方法个数问题（忽略0） 1. 斐波那契数列 1 1 2 3 5 8 13 21 34 即F(n)+F(n+1)=F(n+2) 说明： 1. 当 n <= 2 时，结果为 1； 2. 当 n > 2 时，结果为F(n)+F(n+1)=F(n+2)； 想法 : 1. 当 n <= 2
递归算法:兔子繁殖问题详解
qq_40477235的博客
11-06 2412
面试题:有一对兔子，从出生后第3个月起每月都生一对小兔子，小兔子长到第3个月后每个月又生一对小兔子，按此规律，假设兔子没有死亡，第一个月有一对刚出生的小兔子，问第20个月有多少只兔子？ 解题思路:第一个月1对兔子也就是2只,第二个月2只兔子,第三个月4只兔子,第五个月6只兔子,第六个月...... public class ArrayList09 { public static void main(String[] args)...
兔子繁殖问题 - 两种递归思路
SnailDream
05-17 9232
兔子繁殖问题 - 两种递归思路 有一对兔子出生，从第三月起，每个月生一对兔子，出生的兔子也是第三月起每个月生一对兔子，请问2年后，共有多少只兔子？ 分析思路—— 斐波那契数列问题，用递归方法解决 我的程序—— 思路一： 传统的递归方法 public static long calculate(long
兔子繁殖问题(递归解决)
热门推荐
贾永翀的博客
09-06 1万+
一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔子都不死，那么一年以后可以繁殖多少对兔子？ 我们不妨拿新出生的一对小兔子分析一下： 第一个月小兔子没有繁殖能力，所以还是一对 两个月后，生下一对小兔对数共有两对 三个月以后，老兔子又生下一对，因为小兔子还没有繁殖能力，所以一共是三对 －－－－－－ 分析:将兔子生长分为三个阶段,”幼兔子”,”中兔子”,
青蛙跳台阶问题和斐波那契数列
最新发布
04-28
青蛙跳台阶问题和斐波那契数列是经典的编程问题。我们来分别介绍一下。 1. 青蛙跳台阶问题 一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法？ 解答： 我们可以用动态...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 31
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

2022horse

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值