斐波那契数列

龙星尘

于 2023-01-04 18:13:23 发布

阅读量2k

点赞数 7

分类专栏：算法文章标签：算法 c++ 递归递推动态规划

本文链接：https://blog.csdn.net/wo_ai_luo_/article/details/128543183

版权

算法专栏收录该内容

65 篇文章 1 订阅

订阅专栏

C++记忆化递归/动态规划求斐波那契数列:

斐波那契数列是什么?

一、斐波那契数列指的是这样一个数列：1、1、2、3、5、8、13、21、…… 这个数列从第三项开始，每一项都等于前两项之和。

二、应用：通常在个别股票中不是太准确，通常在指数上有用。当市场行情处于重要关键变盘时间区域时，这些数字可以确定具体的变盘时间。使用斐波那契数列时可以由市场中某个重要的阶段变盘点向未来市场推算，到达时间时市场发生方向变化的概率较大。

第一种解法(递归法):

利用C++求解斐波那契数列第N项数字是什么?我们可以用C++算法,递归法来进行表示.我们知道,斐波那契数列的每一项数字都等于前面两项数字之和,那么用计算机函数来表示,若fun为求斐波那契数列的第N项的函数,那么fun(N)=fun(N-1)+fun(N-2).

而且我们知道,斐波那契数列数列的第一项和第二项都为1,但是我们在算fun(2)的时候,需要fun(1)+fun(0).第一项数字为1是肯定的,那第0项数字呢?我们就将它姑且当作为0,也可以解决这个问题!

C++递归法求斐波那契数列:

#include<bits/stdc++.h> //万能头文件 
using namespace std; //批准使用std 
int fun(int n){ //递归函数,求斐波那契数列的第N项数字 
	if(n==0) //如果是第0项数字 
	  return 0; //返回0 
	if(n==1) //如果求第一项数字 
	  return 1; //返回1 
	return fun(n-1)+fun(n-2); //进行递归式调用 
}
int main(){ //主函数 
	while(1){ //无限循环输入 
		int n; //定义整数,代表斐波那契数列的第n项数字 
		cin>>n; //输入n 
		cout<<fun(n)<<endl; //输出斐波那契数列的第n项数字的值		
	}
	return 0; //结束 
}

第一种解法的效率:

fun(n)=

fun(n-1)= fun(n-2)=

fun(n-1-1)= fun(n-1-2)= fun(n-2-1)= fun(n-2-2)=

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

fun(2)= ............................................

fun(1)=1 fun(0)=0 .................................................

最后得出结论,第一种解法普通递归法的时间复杂度为O(2^n).时间复杂度实在是太大了,虽然这样写代码很简短,比其他两种算法都短,但是由于时间效率太慢,不建议使用!

第二种解法(记忆化递归/动态规划):

第一种普通递归法为什么那么的慢呢?那是因为它重复计算了很多个以前早就已经计算过的值,相当于重复计算,所以时间非常的慢.我们要怎么优化呢?当然是避免重复运算了!怎么避免呢?自然是将我们计算过的值存下来,第二次还需要这个值的时候不需要计算了,直接把之前存下来的那个值返回回去就可以了!

我们刚开始,需要进行初始化,就是将这个记录所有需要计算的值的这个数组初始化(第i个下标的值代表斐波那契数列的第i项数字的值),初始化为-1!为什么呢?这样体现了做标记的作用,代表这个下标所存的斐波那契数列的第i项数字的值还没有算过.这样在递归过程中,如果是-1,代表没有算过,进行赋值,如果算过来,不需要递归重复计算了,直接将这个的值返回回去就可以了!

因为我们知道斐波那契数列的第一项和第二项是什么,所以在最开始就要进行赋值f[0]=0(第0项自然为0)f[1]=1;f[2]=1;然后就可以进行递归了!

这种算法既可以称为"记忆化递归"(毕竟将算过的东西存起来,就是记录下来了),它还有一个名字,是一种很通用的算法"动态规划"!

C++记忆化递归/动态规划求斐波那契数列:

#include<bits/stdc++.h>  //万能头文件 
using namespace std; //允许使用std里面的函数及类 
long long f[5000000]; //记忆化的数组 
long long fun(int n){ //求斐波那契数列的第n项数字 
	if(n==0) //如果是第0项 
	  return 0; //返回值为0 
	if(n==1) //如果求第一项 
	  return 1; //那么返回值为1 
	if(f[n]==-1) //如果这个值没有计算过 
	  f[n]=fun(n-1)+fun(n-2); //进行递归存储计算 
	return f[n]; //计算过的话就直接返回 
}
int main(){ //主函数 
	memset(f,-1,sizeof(f)); //将f这个数组里面的每一个值赋值为-1 
	f[0]=0; //将第0项赋值为0 
	f[1]=1; //将第1项赋值为1 
	f[2]=1; //将第2项赋值为1 
	while(1){ //无限循环输入 
  		int n; //定义整数,代表斐波那契数列的第n项数字 
    	cin>>n; //输入n 
    	cout<<fun(n)<<endl;	//利用记忆化递归/动态规划算法函数求斐波那契数列的第n项数字的值	
	}
    return 0; //结束 
}

第二种解法的效率:

将每一个所计算出来的值记录下来,时间复杂度为O(N^2).已经算是非常快的了!比之前的普通递归快了很多倍了!

第三种解法(递推):

我们在第二种解法中已经看到,可以将值存起来进行计算,不过第二种方法是自上而下来进行计算,和第一种普通递归一样,不过省略了重复的计算步骤.

而我们第三种解法,是自下而上计算:

我们都知道,第一个数为1,第二个数也为1,可以存入数组f里面,那么f[3]是不是等于f[1]+f[2]=2了呢?算出了f[3],f[4]就等于f[2]+f[3]=3了!

这样自下而上计算非常的简洁迅速,快到了极点,堪称斐波那契数列最快的算法之一了.

C++递推解法:

#include<bits/stdc++.h> //万能头文件 
using namespace std; //允许使用std里面的函数及类 
long long f[5000000]; //记忆化的数组
int main(){ //主函数 
    long long n; //定义整数,代表斐波那契数列的第n项数字 
    f[1]=f[2]=1; //将斐波那契数列的第一项和第二项初始化为1 
    cin>>n; //输入n 
    for(long long i=3;i<=n;i++) //从第三项开始自下而上计算 
      f[i]=f[i-2]+f[i-1]; //f[i-2]和f[i-1]的值绝对是算出来了的 
    cout<<f[n]<<endl;// 输出数组下标为n的值 
    return 0; //结束 
}