斐波那契数列算法分析Word文档格式.docx
《斐波那契数列算法分析Word文档格式.docx》由会员分享，可在线阅读，更多相关《斐波那契数列算法分析Word文档格式.docx（9页珍藏版）》请在冰豆网上搜索。
递归程序1：
Fibonacci数列可以用很直观的二叉递归程序来写，用C++语言的描述如下：
longfib1（intn）
{
if（n<
=2）
return1;
}
else
returnfib1（n-1）+fib1（n-2）;
看上去程序的递归使用很恰当，可是在用VC2005的环境下测试n=37的时候用了大约3s，而n=45的时候基本下楼打完饭也看不到结果……显然这种递归的效率太低了！
！
递归效率分析：
例如，用下面一个测试函数：
longfib1（intn,int*arr）
arr[n]++;
{
}
else
returnfib1（n-1,arr）+fib1（n-2,arr）;
这时，可以得到每个fib（i）被计算的次数：
fib（10）=1fib（9）=1fib（8）=2fib（7）=3
fib（6）=5fib（5）=8fib（4）=13fib（3）=21
fib
（2）=34fib
（1）=55fib（0）=34
可见，计算次数呈反向的Fibonacci数列，这显然造成了大量重复计算。
我们令T（N）为函数fib（n）的运行时间，当N>
=2的时候我们分析可知：
T（N）=T（N-1）+T（N-2）+2
而fib（n）=fib（n-1）+fib（n-2），所以有T（N）>
=fib（n），归纳法证明可得：
fib（N）<
（5/3）^N
当N>
4时，fib（N）>
=（3/2）^N
标准写法：
显然这个O（（3/2）^N）是以指数增长的算法，基本上是最坏的情况。
其实，这违反了递归的一个规则：
合成效益法则。
合成效益法则（Compoundinterestrule）：
在求解一个问题的同一实例的时候，切勿在不同的递归调用中做重复性的工作。
所以在上面的代码中调用fib（N-1）的时候实际上同时计算了fib（N-2）。
这种小的重复计算在递归过程中就会产生巨大的运行时间。
递归程序2：
用一叉递归程序就可以得到近似线性的效率，用C++语言的描述如下：
longfib（intn,longa,longb,intcount）
if（count==n）
returnb;
returnfib（n,b,a+b,++count）;
longfib2（intn）
returnfib（n,0,1,1）;
这种方法虽然是递归了，但是并不直观，而且效率上相比下面的迭代循环并没有优势。
迭代解法：
Fibonacci数列用迭代程序来写也很容易，用C++语言的描述如下：
//也可以用数组将每次计算的f（n）存储下来，用来下次计算用（空间换时间）
longfib3（intn）
longx=0,y=1;
for（intj=1;
j<
n;
j++）
y=x+y;
x=y-x;
returny;
这时程序的效率显然为O（N），N=45的时候<
1s就能得到结果。
矩阵乘法：
我们将数列写成：
Fibonacci[0]=0，Fibonacci[1]=1
Fibonacci[n]=Fibonacci[n-1]+Fibonacci[n-2]（n>
可以将它写成矩阵乘法形式：
将右边连续的展开就得到：
下面就是要用O（log（n））的算法计算：
显然用二分法来求，结合一些面向对象的概念，C++代码如下：
classMatrix
public:
longmatr[2][2];
Matrix（constMatrix&
rhs）;
Matrix（longa,longb,longc,longd）;
Matrix&
operator=（constMatrix&
）;
friendMatrixoperator*（constMatrix&
lhs,constMatrix&
rhs）
Matrixret（0,0,0,0）;
[0][0]=[0][0]*[0][0]+[0][1]*[1][0];
[0][1]=[0][0]*[0][1]+[0][1]*[1][1];
[1][0]=[1][0]*[0][0]+[1][1]*[1][0];
[1][1]=[1][0]*[0][1]+[1][1]*[1][1];
returnret;
};
Matrix:
:
Matrix（longa,longb,longc,longd）
this->
matr[0][0]=a;
matr[0][1]=b;
matr[1][0]=c;
matr[1][1]=d;
Matrix（constMatrix&
matr[0][0]=[0][0];
matr[0][1]=[0][1];
matr[1][0]=[1][0];
matr[1][1]=[1][1];
Matrix&
return*this;
Matrixpower（constMatrix&
m,intn）
if（n==1）
returnm;
if（n%2==0）
returnpower（m*m,n/2）;
returnpower（m*m,n/2）*m;
longfib4（intn）
Matrixmatrix0（1,1,1,0）;
matrix0=power（matrix0,n-1）;
[0][0];
这时程序的效率为O（log（N））。
公式解法：
在O
（1）的时间就能求得到F（n）了：
注意：
其中[x]表示取距离x最近的整数。
用C++写的代码如下：
longfib5（intn）
doublez=sqrt;
doublex=（1+z）/2;
doubley=（1-z）/2;
return（pow（x,n）-pow（y,n））/z+;
这个与数学库实现开方和乘方本身效率有关的，我想应该还是在O（log（n））的效率。
总结：
上面给出了5中求解斐波那契数列的方法，用测试程序主函数如下：
intmain（）
cout<
<
fib1（45）<
endl;
fib2（45）<
fib3（45）<
fib4（45）<
cout<
fib5（45）<
return0;
函数fib1会等待好久，其它的都能很快得出结果，并且相同为：
。
而后面两种只有在的时候会显示出优势。
由于我的程序都没有涉及到高精度，所以要是求大数据的话，可以通过取模来获得结果的后4位来测试效率与正确性。
另外斐波那契数列在实际工作中应该用的很少，尤其是当数据n很大的时候（例如：
），所以综合考虑基本普通的非递归O（n）方法就很好了，没有必要用矩阵乘法。
1、N皇后问题算法设计
ALGORITHM
procedurePLACE（k）
//如果一个皇后能放在第k行的X（k）列，则返
回true；
否则返回false。
X是一个全程数
组，进入此过程时已置了k个值。
//
globalX（1：
k）；
integeri，k
i←1
whilei<
kdo
ifX（i）＝X（k）//在同一列有两个皇后//
orABS（X（i）－X（k））＝ABS（i－k）
//在同——条斜角线上//
thenreturn（false）
endif
i←i+1
repeat
return（true）//满足约束//
endPLACE
procedureNQUEENS（n）
//此过程使用回溯法求出在一个n*n棋盘上放置n个皇后，使其能互相攻击的所有可能位置//
X
（1）←0；
k←1//k是当前行；
X（k）是当前列//
Whilek>
0do//对所有的行执行以下语句//
{X（k）←X（k）+1//移到下一列//
WhileX（k）≤nandnotPLACE（k）do
{X（k）←X（k）十l;
}//如果第k个皇后的列X（k）不合理，就看下一列//
ifX（k）≤n//找到一个位置//
thenifk=n//是一个完整的解吗//
thenprint（X）//是，打印这个数组//
else{k←k+1；
X（k）←0；
endif//扩展，搜索下一个皇后//
elsek←k－1//回溯//
endif
endNQUEENS
Program:
#include<
>
intk=0,a[20],j=1,flag,n,c=0;
//k为解的个数,n为皇后的个数,flag标记有没有放置皇后
voidlycQueen（）{//递归求解函数
inti,h;
//i为行号,h为列号
for（h=1;
h<
=n;
h++）{
a[j]=h;
for（i=1;
i<
j;
i++）{//将第j个皇后的位置依次跟前面j-1个皇后比较
if（a[i]==a[j]||abs（a[j]-a[i]）==abs（j-i））{flag=0;
break;
}//两个皇后在同一行或者同一对角线上,冲突
elseflag=1;
//没冲突,放置一个皇后
}//for
if（flag==0&
&
a[j]!
=n）continue;
//没试探完,继续试探
if（flag==1&
j==n）{//放置完n个皇后,得到一个解
k=k+1;
c=1;
//解的个数加1
i++）
printf（"
%d"
a[i]）;
//输出第i个皇后放置的行号
\n"
if（a[j]==n）
flag=0;
}//if
j!
=n）{j++;
lycQueen（）;
}//递归调用
a[j]==n）{j--;
}//回溯,退回去重新试探
}//lycQueen
voidmain（）{
inti;
请输入皇后的个数:
"
scanf（"
&
n）;
//输入皇后的个数n
j=1;
i++）{
a[j]=i;
j=j+1;
//调用lycQueen函数
if（c==1）j=1;
解的个数为%d个\n"
k）;
}//main
升级会员 