2012年5月7日---基于斐波那契数列的时间复杂度分析

在算法中，时间复杂度是衡量一个算法好坏的重要标准。

递归调用在算法中可以非常直观有效的解决我们的问题，但是由于其调用的时候需要花大量的时间，所以我们一般都会刻意的避免使用递归去完成我们的算法。

在这里，我就用斐波那契数列的递归构造和非递归构造来分析递归和非递归的时间复杂度。

先看具体的代码极其运行的时间：

 

Java代码  

1. /* 
2.  * 比较递归和非递归求斐波那契数的时间效率 
3.  * @version 2012/5/7 
4.  * @author akon 
5.  */  
6. package com.akon405.www;  
7.   
8. public class Fibonacci {  
9.     //递归求斐波那契数列  
10.     public int rFibonacci(int n){  
11.         int x=n;  
12.         if(x<=1){  
13.             return x;  
14.         }  
15.         x=rFibonacci(x-1)+rFibonacci(x-2);  
16.         return x;  
17.     }  
18.     //非递归求斐波那契数列  
19.     public int uRFibonacci(int n){  
20.         int x=1;  
21.         int y=1;  
22.         int tmp;  
23.         for(int i=2;i<n;i++){  
24.             tmp=x;  
25.             x=y;  
26.             y=y+tmp;  
27.         }  
28.         return y;  
29.     }  
30.     public static void main(String[] args) {  
31.         double d1,d2,d3;  
32.         Fibonacci f=new Fibonacci();  
33.         System.out.println("递归求斐波那契数列：");  
34.         d1=System.currentTimeMillis();  
35.         for(int i=1;i<=40;i++){  
36.         System.out.println(f.rFibonacci(i));  
37.         }  
38.         d2=System.currentTimeMillis();  
39.         d3=d2-d1;  
40.         System.out.println("递归求斐波那契数列的时间:"+d3);  
41.         System.out.println("非递归求斐波那契数列：");  
42.         d1=System.currentTimeMillis();  
43.         for(int i=1;i<=40;i++){  
44.             System.out.println(f.uRFibonacci(i));  
45.         }  
46.         d2=System.currentTimeMillis();  
47.         d3=d2-d1;  
48.         System.out.println("非递归求斐波那契数列的时间:"+d3);  
49.     }  
50. }  

Java代码  

1. 运算结果：（只保留部分结果）  

Java代码  

1. <pre name="code" class="java">递归求斐波那契数列：  
2. 1  
3. 1  
4. 2  
5. 3  
6. 5  
7. .  
8. .  
9. 102334155  
10. 递归求斐波那契数列的时间:4322.0  
11. 非递归求斐波那契数列：  
12. 1  
13. 1  
14. 2  
15. 3  
16. 5  
17. .  
18. .  
19. 102334155  
20. 非递归求斐波那契数列的时间:3.0  
21. </pre>  
22.  通过结果就可以大致看出，递归调用的时间是非递归调用的很多倍。并且这种情况在n越大的时候越明显。  

 

在分析算法的时间复杂度的时候，我们也可以得到相同的结果，非递归使用的是for循环，其时间复杂度为O(n)。而递归的时间复杂度则比较复杂，其分析出来为O(2^n)。

这里需要说明的就是，非递归的for循环其时间复杂度O(n)虽然很小，但是其空间复杂度缺比递归调用差得多。因为，for循环在每次循环的时候，都把相应的数值保存下来了，而递归调用却不会保存相应的数值。