每日一类-斐波那契数列花式计算

概念

引致百度百科：斐波那契数列（Fibonacci sequence），又称黄金分割数列，因数学家莱昂纳多·斐波那契（Leonardo Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、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*）...

规律

数列项数	数值
0	0
1	1
2	1
3	2
4	3
5	5
6	8
.....	....
n	f(n-1) + f(n-2)

从列表的规律上看，当数列项数n<=1时，数列值与项数相等，当n>1后，n-1数列值 加上 n-2数列值之和。

实现

方式1：递归方式

    /**
     * a 为项数
     * @param n
     * @return
     */
    public static int fib1(int n) {
        if (n <= 1){
            return n;
        }
        return fib1(n - 1) + fib1(n - 2);
    }

解析：

按照上面总结规律，很容易得到上面的实现算法，但是，存在一个问题，如果n等于64之后，明显耗时大大增强，甚至跑不动。究其原因，该算法的时间复杂度为O(2^n)

看上图，如果项数n够大，每一层的计算次数会越来越明显，几乎是2^n的递增规律，所以说此处递归的算法时间复杂度为 O(2^n)。至于为什么耗时那么夸张，因为递归算法的计算存在重复计算的弊端，比如上图的fn(2) 重复计算了好几遍

方式2：循环计算法 

    /**
     * a 为项数
     * @param n
     * @return
     */
    public static int fib2(int n) {
        if (n <= 1){
            return n;
        }
        int prev1 = 0;
        int prev2 = 1;
        for (int i = 0; i < n - 1; i++) {
            int sum = prev1  + prev2;
            prev1 = prev2;
            prev2 = sum;
        }
        return prev2;
    }

上面算法关键在于2点：

1：循环次数，计算第n个项数时，除去第0项，第1项，后面数值都需要计算，计算次数刚好是n-1次。

2：计算的规律，prev1 + prev2，后面需要进行赋值转换，规律如下图

上面方案每次循环都需要新声明一个sum，有点浪费空间，新改进方案

    /**
     * a 为项数
     * @param n
     * @return
     */
    public static int fib3(int n) {
        if (n <= 1){
            return n;
        }
        int prev1 = 0;
        int prev2 = 1;
        while (n-- > 1) {
            prev2 += prev1;
            prev1 = prev2 - prev1;
        }
        return prev2;
    }

上面2中计算方式，循环计算的次数是n-1次，算法的时间复杂度是O(n)相对于方式1来说快多了。

方式3：公式法

斐波那契数列是有现成的计算公式来的，所以，直接套公式是首选

    /**
     * a 为项数
     * @param n
     * @return
     */
    public static int fib4(int n) {
        double c = Math.sqrt(5);
        double ret = (Math.pow((1 + c) / 2, n) - Math.pow((1 - c) / 2, n)) / c;
        return (int) ret;
    }

一次性算出来，算法时间复杂度为O(1)，为全场最佳。