两种方法实现Fibonacci数列。考虑性能对比。
方法1：迭代（考虑合成效益法则等问题）
方法2：保存上一个值和当前值，用空间换时间，循环算法复杂度O(n)
方法3： 矩阵乘法计算 复杂度O(logn)
运行结果如下：
使用迭代方法计算： 89 使用循环方法计算89 fib[0]: 34 fib[1]: 55 fib[2]: 34 fib[3]: 21 fib[4]: 13 fib[5]: 8 fib[6]: 5 fib[7]: 3 fib[8]: 2 fib[9]: 1 fib[10]: 1 请按任意键继续. . .
注意，使用递归法进行计算时，可以看到进行了很多重复运算，所以当n=45时，递归算法需要很长时间才能计算出结果。而迭代计算时间复杂度只有O(n)，可以很快计算的得出结果。
PS：O(n) VS O(lgn)
从此图可以看出复杂度为O(n)和O(logn)的程序性能实际上会差很多，并且数据量越大，差距会越大。1000个数据使用logn方法只需要10次即可，但是O(n)算法需要1000次。
将一个0.11mm厚的纸折叠25次，得到的厚度是一个富士山的高度。所以指数增长会是非常恐怖的增长速度。
矩阵乘法：
我们将数列写成：
Fibonacci[0] = 0，Fibonacci[1] = 1
Fibonacci[n] = Fibonacci[n-1] + Fibonacci[n-2] (n >= 2)
可以将它写成矩阵乘法形式：
将右边连续的展开就得到：
下面就是要用O(log(n))的算法计算：
显然用二分法来求，结合一些面向对象的概念，C++代码如下：
class Matrix
{
public:
long matr[2][2];
Matrix(const Matrix&rhs);
Matrix(long a, long b, long c, long d);
Matrix& operator=(const Matrix&);
friend Matrix operator*(const Matrix& lhs, const Matrix& rhs)
{
Matrix ret(0,0,0,0);
ret.matr[0][0] = lhs.matr[0][0]*rhs.matr[0][0] + lhs.matr[0][1]*rhs.matr[1][0];
ret.matr[0][1] = lhs.matr[0][0]*rhs.matr[0][1] + lhs.matr[0][1]*rhs.matr[1][1];
ret.matr[1][0] = lhs.matr[1][0]*rhs.matr[0][0] + lhs.matr[1][1]*rhs.matr[1][0];
ret.matr[1][1] = lhs.matr[1][0]*rhs.matr[0][1] + lhs.matr[1][1]*rhs.matr[1][1];
return ret;
}
};
Matrix::Matrix(long a, long b, long c, long d)
{
this->matr[0][0] = a;
this->matr[0][1] = b;
this->matr[1][0] = c;
this->matr[1][1] = d;
}
Matrix::Matrix(const Matrix &rhs)
{
this->matr[0][0] = rhs.matr[0][0];
this->matr[0][1] = rhs.matr[0][1];
this->matr[1][0] = rhs.matr[1][0];
this->matr[1][1] = rhs.matr[1][1];
}
Matrix& Matrix::operator =(const Matrix &rhs)
{
this->matr[0][0] = rhs.matr[0][0];
this->matr[0][1] = rhs.matr[0][1];
this->matr[1][0] = rhs.matr[1][0];
this->matr[1][1] = rhs.matr[1][1];
return *this;
}
Matrix power(const Matrix& m, int n)
{
if (n == 1)
return m;
if (n%2 == 0)
return power(m*m, n/2);
else
return power(m*m, n/2) * m;
}
long fib4 (int n)
{
Matrix matrix0(1, 1, 1, 0);
matrix0 = power(matrix0, n-1);
return matrix0.matr[0][0];
}
这时程序的效率为O（log(N)） 。
公式解法：
在O（1）的时间就能求得到F(n)了：
注意：其中[x]表示取距离x最近的整数。
用C++写的代码如下：
long fib5(int n)
{
double z = sqrt(5.0);
double x = (1 + z)/2;
double y = (1 - z)/2;
return (pow(x, n) - pow(y, n))/z + 0.5;
}
这个与数学库实现开方和乘方本身效率有关的，我想应该还是在O(log(n))的效率。
总结：
上面给出了5中求解斐波那契数列的方法，用测试程序主函数如下：
int main()
{
cout << fib1(45) << endl;
cout << fib2(45) << endl;
cout << fib3(45) << endl;
cout << fib4(45) << endl;
cout << fib5(45) << endl;
return 0;
}
函数fib1会等待好久，其它的都能很快得出结果，并且相同为：1134903170。
而后面两种只有在n = 1000000000的时候会显示出优势。由于我的程序都没有涉及到高精度，所以要是求大数据的话，可以通过取模来获得结果的后4位来测试效率与正确性。
另外斐波那契数列在实际工作中应该用的很少，尤其是当数据n很大的时候（例如：1000000000），所以综合考虑基本普通的非递归O(n)方法就很好了，没有必要用矩阵乘法。
在思考算法复杂度时，这种感觉是最重要的。例如要操作的数据有1000万条，如果能选择对数算法，那么只需几十次计算就可以了。相反，如果选错了算法，使用O(n2)或O(2n)的算法实现的话，写出的程序即使只有几百条数据，也要浪费相当多资源。
#include <iostream> #include <vector> #include <string> #include <cmath> #include <fstream> using namespace std; class Matrix { public: long matr[2][2]; Matrix(const Matrix&rhs); Matrix(long a, long b, long c, long d); Matrix& operator=(const Matrix&); friend Matrix operator*(const Matrix& lhs, const Matrix& rhs) { Matrix ret(0,0,0,0); ret.matr[0][0] = lhs.matr[0][0]*rhs.matr[0][0] + lhs.matr[0][1]*rhs.matr[1][0]; ret.matr[0][1] = lhs.matr[0][0]*rhs.matr[0][1] + lhs.matr[0][1]*rhs.matr[1][1]; ret.matr[1][0] = lhs.matr[1][0]*rhs.matr[0][0] + lhs.matr[1][1]*rhs.matr[1][0]; ret.matr[1][1] = lhs.matr[1][0]*rhs.matr[0][1] + lhs.matr[1][1]*rhs.matr[1][1]; return ret; } }; Matrix::Matrix(long a, long b, long c, long d) { this->matr[0][0] = a; this->matr[0][1] = b; this->matr[1][0] = c; this->matr[1][1] = d; } Matrix::Matrix(const Matrix &rhs) { this->matr[0][0] = rhs.matr[0][0]; this->matr[0][1] = rhs.matr[0][1]; this->matr[1][0] = rhs.matr[1][0]; this->matr[1][1] = rhs.matr[1][1]; } Matrix& Matrix::operator =(const Matrix &rhs) { this->matr[0][0] = rhs.matr[0][0]; this->matr[0][1] = rhs.matr[0][1]; this->matr[1][0] = rhs.matr[1][0]; this->matr[1][1] = rhs.matr[1][1]; return *this; } Matrix power(const Matrix& m, int n) { if (n == 1) return m; if (n%2 == 0) return power(m*m, n/2); else return power(m*m, n/2) * m; } //普通递归 long fib1(int n) { if (n <= 2) { return 1; } else { return fib1(n-1) + fib1(n-2); } } /*上面的效率分析代码 long fib1(int n, int* arr) { arr[n]++; if (n <= 1) { return 1; } else { return fib1(n-1, arr) + fib1(n-2, arr); } } */ long fib(int n, long a, long b, int count) { if (count == n) return b; return fib(n, b, a+b, ++count); } //一叉递归 long fib2(int n) { return fib(n, 0, 1, 1); } //非递归方法O(n) long fib3 (int n) { long x = 0, y = 1; for (int j = 1; j < n; j++) { y = x + y; x = y - x; } return y; } //矩阵乘法O(log(n)) long fib4 (int n) { Matrix matrix0(1, 1, 1, 0); matrix0 = power(matrix0, n-1); return matrix0.matr[0][0]; } //公式法O(1) long fib5(int n) { double z = sqrt(5.0); double x = (1 + z)/2; double y = (1 - z)/2; return (pow(x, n) - pow(y, n))/z + 0.5; } int main() { //n = 45时候fib1()很慢 int n = 10; cout << fib1(n) << endl; cout << fib2(n) << endl; cout << fib3(n) << endl; cout << fib4(n) << endl; cout << fib5(n) << endl; return 0; }