斐波那契数列的各种算法

2019独角兽企业重金招聘Python工程师标准>>>

算法1(递归算法):

/*递归实现*/
#include<stdio.h>
int fib1(int a){
 if(a<=2)
 {
  return 1;
 }
 else{
  return fib1(a-1)+fib1(a-2);
 }
}
/*求第n项斐波那契额数的值*/
void main()
{
 int n;
 printf("please input the number:");
 scanf("%d",&n);
 
 fib1(n);
 printf("the number is:%d",fib1(n));
}

    说明:最好理解的算法,和人的思路相当接近,对应的数学描述很清晰,容易编程.但是在C++语言中是使用栈机制实现的,如果使用递归函数,将会占用大 量的内存资源,对内存中的栈区进行掠夺,在大量调用递归函数之后很可能造成内存崩溃,就算不崩溃,也会是长时间的运算.在调用了clock函数后,计算出 了递归函数的耗时,是四个函数中最大的.而且这是个致命的缺点.时间复杂度为O(2n)(括号内为2的n次方).

算法2:迭代算法

/*迭代算法*/
#include<stdio.h>
long fib3(int n){
 long x=0,y=1;
 for(int j=1;j<n;j++){
  y=x+y;
  x=y-x;
 }
 return y;
}
/*求第n项斐波那契额数的值*/
void main()
{
 int n;
 printf("please input the number:");
 scanf("%d",&n);
 
 fib3(n);
 printf("the number is:%d\n",fib3(n));
}

5种算法

#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;
}

转载于:https://my.oschina.net/u/1423127/blog/277960