js更高效的实现斐波那契数列

前言：

斐波那契数列数列：0 1 1 2 3 5 8 13...，用数学公式表示为：fn(n) = fn(n-1) + fn(n-2), n>1; fn(0) = 0; fn(1) = 1; 简单的来说就是后一项是前两项只和。




js实现斐波那契数列的三种方式：

方法一：递归

一提到斐波那契数列估计很多人和我的第一反应是一样的，那便是递归。用递归的方式实现一下，代码如下：

    function fabonacci(n) {
      if (n === 0) { 
        return 0;
      } else if (n === 1) {
        return 1;
      } else {
        return fabonacci(n - 1) + fabonacci(n -2);
      }
    }
    var start = new Date();
    var result = fabonacci(50);
    var end = new Date();
    console.log('迭代', result, end.getTime() - start.getTime());

如上我以n=50为例，测算了一下fn(50)所需要的时间，差点吓死宝宝，255s才出答案，也就是说4分多一点才算出来！！！细分析下原因：

 f(0) = 0* f(1) = 1

 f(2) = f(1) + f(0)

 f(3) = f(2) + f(1) 

       = (f(1) + f(0)) + f(1)

 f(4) = f(3) + f(2) 

       = (f(2) + f(1)) + (f(1) + f(0)) 

       = ((f(1) + f(0)) + f(1)) + (f(1) + f(0))

 f(5) = f(4) + f(3) = (f(3) + f(2)) + (f(2) + f(1)) 

       = ((f(2) + f(1)) + (f(1) + f(0))) + ((f(1) + f(0)) + f(1))

       = (((f(1) + f(0)) + f(1)) + (f(1) + f(0))) + ((f(1) + f(0)) + f(1))

 ...

我们发现递归造成了大量的重复运算。其的时间复杂度为O(2^n)，空间复杂度为O(n)；

方法二：用一个变量来存储算过的数，解决迭代中的重复计算

    var cache = {
      0: 0,
      1: 1
    }
    function fabonacci(n) {
      if (typeof cache[n] === 'number') {
        return cache[n];
      }
      var result = cache[n] = fabonacci(n - 1) + fabonacci(n - 2);
      return result;
     }
    var start = new Date();
    var result = fabonacci(50);
    var end = new Date();
    console.log('方法二', result, end.getTime() - start.getTime());

优雅一点的写法如下：

    var cache = {
      0: 0,
      1: 1
    }
    function fabonacci(n) {
      return typeof cache[n] === 'number' ? cache[n] : cache[n] = fabonacci(n - 1) + fabonacci(n - 2);
    }

其中cache也可以换成数组写法如下：

    var cache = [0, 1];
    function fabonacci(n) {
      return typeof cache[n] === 'number' ? cache[n] : cache[n] = fabonacci(n - 1) + fabonacci(n - 2);
    }

有的同志可能喜欢函数式的写法，写法如下：

    function fabonacci() {
      var cache = {
        0: 0,
        1: 1
      }
      return function fabonacci_(n) {
        return typeof cache[n] === 'number' ? cache[n] : cache[n] = fabonacci_(n - 1) + fabonacci_(n - 2);
      }
    }

    var start = new Date();
    var result = fabonacci()(50);
    var end = new Date();
    console.log('方法二4', result, end.getTime() - start.getTime());

你会惊奇的发现，这个大大缩短了运算时间，只要4ms。时间复杂度为O(n)，空间复杂度为O(n)

方法三：用for循环来实现，时间复杂度为O(n)，空间复杂度为O(1)，用时1ms!

递归是往里探寻，比n小的每个值都要重算一遍，同样比n-1小的每一个值都要重新算一遍。

而for循环有点相反的意思，它是从底层算起，知道到达fn(n)。

    function fabonacci(n) {
      var last = 0;
      var laster = 1;
      var current = last;
      for (var i = 1; i <= n; i++) {
        last = laster;
        laster = current;
        current = last + laster;
      }
      return current;
    }

    var start = new Date();
    var result = fabonacci(50);
    var end = new Date();
    console.log('方法三1', result, end.getTime() - start.getTime());

该方法变量处理太多，故做了下面的优化版本，避免多个变量的改变

    function fabonacci(n) {
      function fabonacci_(n, a, b) {
        if (n === 0) {
          return a; //注意这里是a，小编第一次写时，写成了0，依旧停留在迭代的思想
        } else {
          return fabonacci_(n - 1, b, a + b);
        }
      }
      return fabonacci_(n, 0, 1);
    }

写了这么多，下次提到斐波那契数列时记得第一反应不要再是递归咯！