前言:
斐波那契数列数列: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);
}
写了这么多,下次提到斐波那契数列时记得第一反应不要再是递归咯!