14天阅读打卡-04-斐波那契数列

14天阅读挑战赛，努力是为了不平庸

        假设现在我们有一对初生的兔子，第 2 个月进入成熟期，第 3 个月开始生育兔子，而 1 对成熟的兔子每个月又会生 1 对兔子，并且这些兔子永远不会老去也不会死，那么一直循环下去的话，你知道一年后会有多少对兔子嘛？

问题分析

我们不妨尝试分析一下这个问题：

-> 第 1 个月，小兔子没有繁殖能力，所以还是 1 对。

-> 第 2 个月，小兔子进入成熟期，还是 1 对

-> 第 3 个月，小兔子有繁殖能力了，生了一对小兔子，所以这个月共有 1 + 1 = 2 对兔子

-> 第 4 个月，小兔子又生了一对小兔子，因此这个月共有 3 对兔子

-> 第 5 个月，小兔子又生了一对兔子，而在第 3 个月出生的兔子也生下了 一对兔子，所以这个

月共有 3 + 5 = 8 对兔子

...........................

不知道你有没有发现，兔子的数量，有一定的规律性可言：

        从第 3 个月 开始，当月的兔子数量 = 上个月的兔子数量 + 当月新生兔子数量，而当月新生兔子数正好等于上上月的兔子数

 因此：

当月的兔子数 = 上月兔子数 + 上上月的兔子数

而且，兔子生长繁殖完美地符合了斐波那契数的特征：1, 1, 2, 3, 5, 8, 13, 21, ....  

斐波那契数列

黄金分割数列

         斐波那契数列（Fibonacci sequence），又称黄金分割数列，因数学家莱昂纳多·斐波那契的姓名而命名。因（Leonardo Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）在现代物理、准晶体结构、化学等领域，斐波那契数列都有直接的应用，为此，美国数学会从 1963 年起出版了以《斐波那契数列季刊》为名的一份数学杂志，用于专门刊载这方面的研究成果。

那么既然知道了兔子序列就是斐波那契数列，那么我们就可以开始设计算法：

1. 首先根据斐波那契数列的定义，我们可以得出以下分段函数的表达式：

算法设计

• 使用递归

递归的代码相对比较简洁易懂，但是如果代码没有写好的话，程序运行的时候容易栈溢出或者循环调用然后栈溢出。

C

/** rabbitSequence.C -- 使用递归计算当月兔子的数量 */
#include <stdio.h>
#include <string.h>

/*
	递归计算兔子数量
 */
unsigned long long int Fib(int n);

int main(int argc, const char *argv[])
{
	// 初始化变量 month 用于存储输入的月份
	int month;
	// 读取用户的输入
	puts("请输入月份：");
	scanf("%d", &month);
	// 计算并输出当月的兔子数量
	printf("%d月份之后的兔子对数为%llu对\n", month, Fib(month));

	return 0;
}

/*
	递归计算兔子数量
 */
unsigned long long int Fib(int n) 
{
	if (n == 1 || n == 2) {
		return 1;
	}
	return Fib(n - 1) + Fib(n - 2);
}

Java

import java.util.Scanner;

/**
 * @Description 使用递归计算当月兔子的数量
 */
public class RabbitSequence {

	public static void main(String[] args) {
		// 创建一个输入扫描仪用于读取用户的输入
		Scanner in = new Scanner(System.in);
		System.out.println("请输入月份");
		// 定义 month 变量并读取用户的输入
		int month = in.nextInt();
		// 计算并输出当月的兔子数量
		System.out.printf("%d月分之后的兔子对数为%d对\n", month, Fib(month));
	
	}

	/**
	 * 递归计算兔子数量
	 * 
	 * @param n 要计算的月份
	 * @return 计算好的兔子对数
	 */
	public static int Fib(int n) {
		if (n == 1 || n == 2) {
			return 1;
		}
		return Fib(n - 1) + Fib(n - 2);
	}
}

运行这个程序你可以发现确实可以得到正确的数量，但是

         当 n 越来越大的时候，你会发现程序运行的越来越慢了，甚至等半天也不出结果，这是因为递归调用会创建大量的函数栈帧和变量，非常耗内存和时间，而且这段代码的时间复杂度达到惊人的指数级，完全称得上是一个爆炸增量函数，那么我们能不能优化这个程序呢，答案是可以的

• 使用循环

        循环不会创建很多变量，占用的内存也比递归小多了，但是用不好也是会死循环的，而且循环相对于递归的解法不是那么容易理解：

C

/** rabbitSequence.C -- 循环计算兔子数量 */
#include <stdio.h>
#include <string.h>

/*
	循环计算兔子数量
 */
unsigned long long int Fib(int n); 

int main(int argc, const char *argv[])
{
	// 初始化变量 month 用于存储输入的月份
	int month;
	// 读取用户的输入
	puts("请输入月份：");
	scanf("%d", &month);
	// 计算并输出当月的兔子数量
	printf("%d 月的兔子对数为 %llu 对\n", month, Fib(month));
	
	return 0;
}

/*
	循环计算兔子数量
 */
unsigned long long int Fib(int n) 
{
	// 如果小于等于 1 则不用计算
	if (n <= 1) {
		return 1;
	}
	// 先保存第一个月和第二个月的兔子数
	unsigned long long int f1 = 1, f2 = 1;
	unsigned long long int i, ret = 1;
	// 使用循环从第三个月开始计算兔子数
	for (i = 2; i < n; i++)
	{
		/*
		  当月的兔子数 = 上个月的兔子 + 上上月的兔子数
		 */
		ret = f1 + f2;
		// 上上月的兔子数等于当月兔子数
		f1 = f2;
		// 上上月的兔子数等于当月兔子数
		f2 = ret;
	}
	return ret;
}

Java

import java.math.BigDecimal;
import java.util.Scanner;

/**
 * @Description 使用循环计算当月兔子的数量
 */
public class RabbitSequence {

	public static void main(String[] args) {
		// 创建一个输入扫描仪用于读取用户的输入
		Scanner in = new Scanner(System.in);
		System.out.println("请输入月份");
		// 定义 month 变量并读取用户的输入
		int month = in.nextInt();
		// 计算并输出当月的兔子数量
		System.out.println(month + "月份之后的兔子对数为" + Fib(month) + "对");

	}

	/**
	 * 循环计算兔子数量
	 *
	 * @param n 要计算的月份
	 * @return 计算好的兔子对数
	 */
	public static BigDecimal Fib(int n) {
		// 如果小于等于 1 则不用计算
		if (n <= 1) {
			return new BigDecimal(n);
		}
		// 先保存第一个月和第二个月的兔子数
		BigDecimal f1 = new BigDecimal(1);
		BigDecimal f2 = new BigDecimal(1);
		// ret 用于返回 计算的兔子数量


		BigDecimal ret = new BigDecimal(1);
		// 使用循环从第三个月开始计算兔子数
		for (int i = 2; i < n; i++)
		{
			/*
			  当月的兔子数 = 上个月的兔子 + 上上月的兔子数
			 */
			ret = f1.add(f2);

			// 上上月的兔子数等于当月兔子数
			f1 = f2;
			// 上上月的兔子数等于当月兔子数
			f2 = ret;
		}
		return ret;
	}
}

可以看出优化后的代码，明显计算速度变快了，时间复杂度为  ，空间复杂度也降到了 

，也可以计算更大的月份了。

        那我们想一想，还有没有更好的算法呢，使得程序的时间复杂度更低？

        事实上，斐波那契数列的时间复杂度还可以降到对数阶 ，有兴趣的同学可以自行查询相关资料，这里不作讨论。

往期打卡

技术文章

1、​​​​​​​14天阅读打卡-01-初识算法

2、14天阅读打卡-02-算法的复杂性

3、14天阅读打卡-03-一棋盘的麦子

4、14天阅读打卡-04-斐波那契数列​​​​​​​

冷知识

        递归是一种编程技巧，不是一类算法也不是某一种数据结构，递归本质上是函数/方法调用自身的一种行为，因为是自己调用自己，所以函数自己的参数传递给了自己，就像植物一样，生于尘土，归于尘土，所以就叫递归。此外，还有一种编程技巧，叫递推。

        循环是一种计算机编程语言中的语句，满足指定的条件，可以重复调用指定的代码片段，循环的存在，丰富了代码的逻辑。计算机编程语言的语法虽然各有不同，但是都有着类似的的循环语句或语法结构，比如 C、C++、Java。