精华内容
下载资源
问答
  • JS递归代码实现 当参数为n时,时间复杂度为f(n) = f(n-1) + f(n-2) 当n为6时,树的高度为5即h=n-1的高度,共有15个节点即2^(h-1)-1个 时间复杂度为O(2^n) = f(2^n-1) - 1 空间复杂度为O(n) = f(n-1)

    JS递归代码实现

    当参数为n时,时间复杂度为f(n) = f(n-1) + f(n-2)

    当n为6时,树的高度为5即h=n-1的高度,共有15个节点即2^(h-1)-1个

    时间复杂度为O(2^n) = f(2^n-1) - 1

    空间复杂度为O(n) = f(n-1)

    展开全文
  • 斐波那契数列:前两项是1,后面的每项是其前两项之和。比如:1 1 2 3 5 8 13… 递归实现: def Fab(n): if n==0 or n==1: return 1 # 递归:函数的自身调用 return Fab(n-1) + Fab(n-2) 递归算法时间复杂度为...

    斐波那契数列:前两项是1,后面的每项是其前两项之和。比如:1 1 2 3 5 8 13…

    递归实现:

    def Fib(n):
        if n==1 or n==2:
            return 1
        # 递归:函数的自身调用
        return Fib(n-1) + Fib(n-2)
    

    在这里插入图片描述
    二叉树的高度是 n - 1,一个高度为k的二叉树最多可以由 2^k - 1
    个叶子节点,也就是递归过程函数调用的次数,所以时间复杂度为 O(2^n),而空间复杂度就是树的高度 S(n)

    展开全文
  • 斐波那契数列我写了四种实现方法: 第一种:递归实现 long long Fib(int n)//递归 { if (n ) { return n; } return Fib(n - 1) + Fib(n - 2); }时间复杂度:O(2^n) 空间复杂度:O(n) 第二种:非递归实现 ...

    斐波那契数列我写了四种实现方法:

    第一种:递归实现

    long long Fib(int n)//递归
    {
    	if (n < 2)
    	{
    		return n;
    	}
    	return Fib(n - 1) + Fib(n - 2);
    }
    时间复杂度:O(2^n)

    空间复杂度:O(n)

    第二种:非递归实现

    long long FibNouR(int n)//非递归
    {
    	long long first = 0;
    	long long second = 1;
    	long long ret;
    	if (n < 2)
    	{
    		return n;
    	}
    	else
    	{
    		for (size_t i = 0; i < n; ++i)
    		{
    			ret = first + second;
    			first = second;
    			second = ret;
    		}
    		return ret;
    	}
    }
    时间复杂度:O(n)

    空间复杂度:O(1)

    第三种:数组实现

    long long*  FibArray(int n)//数组
    {
    	long long* array = new long long[n + 1];
    	array[0] = 0;
    	if (n == 0)
    		return array;
    	array[1] = 1;
    	for (size_t i = 2; i < n; ++i)
    	{
    		array[i] = array[i - 1] + array[i - 2];
    	}
    	return array;
    }
    时间复杂度:O(n)

    空间复杂度:O(n)

    第四种:数组的优化

    long long FibN2(int n)//优化
    {
    	long long fibarray[3] = { 0, 1, n };
    	for (size_t i = 2; i < n; ++i)
    	{
    		fibarray[2] = fibarray[1] + fibarray[0];
    		fibarray[0] = fibarray[1];
    		fibarray[1] = fibarray[2];
    	}
    	return fibarray[2];
    }
    时间复杂度:O(n)

    空间复杂度:O(1)

    展开全文
  • 我看在家修炼编程技术是不错的选择,「用Python实现斐波那契数列」是我们在知识星球中每周给大家安排的一道题,你也可以先思考一下有哪些实现方法,说不定哪天面试就能派上用场,终有一日当上CTO...

    作者:刘志军,6年+Python使用经验, 高级开发工程师,目前在互联网医疗行业从事Web系统构架工作

    个人公众号:Python之禅(微信ID:vttalk)

    122646193_2_20180122102907565

    单身汪节早已被商家重新定义,除了买买买还可以做点什么?我看在家修炼编程技术是不错的选择,「用Python实现斐波那契数列」是我们在知识星球中每周给大家安排的一道题,你也可以先思考一下有哪些实现方法,说不定哪天面试就能派上用场,终有一日当上CTO赢取白富美从此走上人生巅峰。

    斐波那契数列(Fibonacci)最早由印度数学家Gopala提出,第一个真正研究斐波那契数列的是意大利数学家 Leonardo Fibonacci,斐波那契数列的定义很简单,用数学函数可表示为:

    数列从0和1开始,之后的数由前两个数相加而得出,例如斐波那契数列的前10个数是:0, 1, 1, 2, 3, 5, 8, 13, 21, 34。

    用 Python 实现斐波那契数列常见的写法有三种,各算法的执行效率也有很大差别,在面试中也会偶尔会被问到,通常面试的时候不是让你简单的用递归写写就完了,还会问你时间复杂度怎样,空间复杂度怎样,有没有可改进的地方。

    递归法

    所谓递归就是指函数的定义中使用了函数自身的方法

    def fib_recur(n):

    assert n >= 0

    if n in (0, 1):

    return n

    return fib_recur(n - 1) + fib_recur(n - 2)

    for i in range(20):

    print(fib_recur(i), end=' ')

    >>>0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

    递归是一种写法最简洁的方法,但它是效率非常低,因为会出现大量的重复计算,时间复杂度是:O(1.618 ^ n),1.618 是黄金分割点。同时受限于 Python 中递归的最大深度是 1000,所以用递归来求解并不是一种可取的办法。

    递推法

    递推法就是从0和1开始,前两项相加逐个求出第3、第4个数,直到求出第n个数的值

    def fib_loop(n):

    a, b = 0, 1

    for i in range(n):

    a, b = b, a + b

    return a

    for i in range(20):

    print(fib_loop(i), end=' ')

    >>>0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

    这种算法的时间复杂是O(n),呈线性增长,如果数据量巨大,速度越到后面会越慢。

    上面两种方式都是使用分而治之的思想,把一个大的问题化小,然后利用小问题的求解得到目标问题的答案。

    矩阵法

    《线性代数》是大学计算机专业的一门课程,教的就是矩阵,那时候觉得这东西学起来很枯燥,没什么用处,工作后你才发现搞机器学习、数据分析、数据建模时大有用处,书到用时方恨少。其实矩阵的本质就是线性方程式。

    斐波那契数列中两个相邻的项分别为:F(n) 和 F(n - 1),如果把这两个数当作一个2行1列的矩阵可表示为:

    因为 F(n) = F(n-1)+F(n-2),所以就有:

    通过反推,其实它是由两个矩阵的乘积得来的

    122646193_6_20180122102907909

    依此类推:

    122646193_7_2018012210290865

    最后可推出:

    122646193_8_20180122102908159

    因此想要求出F(n)的值,只要能求出右边矩阵的n-1次方的值,最后求得两矩阵乘积,取新矩阵的第一行的第一列的值即可,比如n=3时,

    122646193_9_20180122102908221

    可以得知F(3)的值2,F(2)的值为1,因为幂运算可以使用二分加速,所以矩阵法的时间复杂度为 O(log n)

    我们可以用科学计算包 numpy 来实现矩阵法:

    import numpy

    def fib_matr(n):

    return (numpy.matrix([[1, 1], [1, 0]]) ** (n - 1) * numpy.matrix([[1], [0]]))[0, 0]

    for i in range(20):

    print(int(fib_matr(i)), end=' ')

    >>>0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

    3中不同的算法效率对比:

    122646193_10_20180122102908362

    从上面图可以看出递归法效率惊人的低,矩阵法在数据量比较大的时候才突显出它的优势,递推法随着数据的变大,所花的时间也越来越大。

    122646193_11_20180122102908581

    Python爱好者社区历史文章大合集:

    展开全文
  • 斐波那契数列是这样一个数列:1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765… 表达式为: (注:斐波那契数列也可从n=0开始,对应的F(0)=0) ...//递归实现斐波那契数列 int fib1(...
  • 5.斐波那契非递归实现 6.怎么在时间复杂度O(1),空间复杂度O(1)下计算斐波那契数 1.斐波那契数简介 斐波那契数列(Fibonacci sequence),又称黄金分割数列、因数学家莱昂纳多·斐波那契(Leonardoda Fibonacci...
  • 递归实现 非递归二分查找: 时间复杂度为O(logn) 时间复杂度为O(1) 2、斐波那契数列 递归 时间复杂度为O(2^n) 时间复杂度为O(1) 非递归 时间复杂度为O(n) 时间复杂度为O(1) 总结1、时间复杂度就是一...
  • 递归代码实现: int Fib(n){ if (n==1 || n==2) ...时间复杂度为 O(2^n) -------------二叉树的深度为h = n-1,叶子节点最多为2^(h-1)个,即为调用次数 空间复杂度 O(n)--------------即为二叉树的深度n-1 ...
  • java实现 class Fibonacci{ //递归 public static int fibonacci_recursion(int n){ if(n==0||n==1){ return 1; } if(n>=2){ return fibonacci_recursion(n-1)+fibonacci_recursion(n-2); } return
  • 首先我们通过递归和遍历求和两种方式来实现斐波那契数列求和: /** * 求斐波那契数列的和(每个数是前两个的和) * 1 1 2 3 5 8 13 21 34 .... */ public static int fib1(int n) { if(n<=1) return n;...
  • 一、二分查找法的时间复杂度int Er_Feng_Find(int arr[],int sz, int data){ int left = 0; int right = sz - 1; int mid = 0; while (left &lt;= right) { mid =(right + left) / 2; if (data &lt;....
  • 一、二分查找的时间复杂度和空间复杂度 二分查找的代码: #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; int Er_Feng_Find(int arr[],int sz, int data) { int left = 0; int right = sz ...
  • 1.时间复杂度: 时间复杂度其实即使算法执行次数n的某个函数f(n),进而分析f(n)随n的变化情况并确定T(n)的数量级。这里用"O"来表示数量级,时间复杂度的表达式为。 T(n)=O(f(n)); 它表示随着问题规模的...
  • 斐波那契数列 1、1、2、3、5、8、13、21、34…… int F(int n)//递归算法 { if(n) return 1; return F(n-1)+F(n-2);//O(n)=2^n }int f(int n)//非递归算法 { int i,j=1,k=1,p=1; for (i=2;i;i
  • #if 0/*斐波那契数列: 题目:写一个函数,输入n,求斐波那契(Fibonacci)数列的第n项,斐波那契数列的定义如下: f(n) = 0 n = 0 ...递归实现时间复杂度是以n的指数的方式递增的。 */long long F
  • 给定整数N,返回斐波那契数列的第N项 斐波那契数列为1,1,2,3,5,8,......也就是除第1项和第2项为1以外,对于第N项,有F(N)=F(N-1)+F(N-2),于是能够很轻松的写出暴力递归的代码。其时间复杂度为O(2^N).int Fibonacci1...
  • 此处使用三种方式实现斐波那契数列递归、递推和通项公式。 实现过程如下: #include&lt;cstring&gt; #include&lt;cstdio&gt; #include&lt;iostream&gt; #include&lt;cmath&gt;...
  • 对于递归算法举例,最经典的就是斐波那契数列了,而它的定义也贴一下: 下面用代码来实现它: 不多解释,因为比较容易,下面来看下输出结果: 那该递归算法的时间复杂度是多少呢?应该时间耗得不多吧,看...
  • 时间复杂度是衡量程序运行的快慢,对于一个程序来说,运行速度的快慢,有很多干扰因素,不同的硬件条件都可能影响到速度的快慢。时间复杂度来衡量,不是精确的衡量,只是单纯从代码本身衡量程序运行的效率来看,用...
  • //二分查找的非递归与递归实现: #include int binarry_Search(int arr[], int len, int value){ //采用左闭右闭区间方式 int left=0,right=len-1; int mid; while(left){ mid=left+((right-left)>>1); //...
  • 斐波那契数列: 0,1,1,2,3,5,8,13,21 … 分析数列可以得出第n列...用递归方式(时间复杂度O(2^N)): func fibo(n int) int { if n <= 0 { return 0 } else if n == 1 { return 1 } else { return
  • 递归时间复杂度为O(n) #include using namespace std; int Fib(size_t N) { int a1 = 0, a2 = 1, a3 = N; if (N return a3; for (size_t idx = 2; idx { a3 = a1 + a2; a1 = a2; a2 = a3; ...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 203
精华内容 81
关键字:

斐波那契数列递归实现时间复杂度