递归处理斐波那契数时的低效率

    某些递归解法的效率如此之低下，以致于必须避免。

    例：斐波那契数（Fibonacci） 早在13世纪，数学家莱昂纳多斐波那契（Leonardo Fibonacci）就提出了一个用以模拟一对兔子后代数目的整数序列，这些后来称为斐波那契序列（Fibonacci sequence）的数名人惊讶的出现在许多应用中。

    序列为：1,1,2,3,5,8,13....

    公式为：F(n) = F(n-1) + F(n-2)

    使用递归算法将造成大量的重复计算，而它每层的递归会形成反向的Fibonacci序列。

    如下如：

    操作----------计算次数

    Fib(5)            1

    Fib(4)            1

    Fib(3)            2

    Fib(2)            3

    Fib(1)            5

    而Fib(0)等于Fib(2)的计算次数

    很明显，此时使用递归算法的效率要低得多。

    以下是我用Java的编写的程序：

1. /**
2.  * f(n)=f(n-1)+f(n-2),使用递归算法将产生级差的效率
3.  * @author scorpio
4.  */
5. public class DiGv {
7.     private static final int NUMBER = 43;
9.     /** 采用递归实现 */
10.     private static int fibonacci_1(int n) {
11.         if (n <= 1) {
12.             return 1;
13.         } else {
14.             return fibonacci_1(n - 1) + fibonacci_1(n - 2);
15.         }
16.     }
18.     /** 采用循环实现,n<1返回0 */
19.     private static int fibonacci_2(int n) {
20.         int sum = 0;
21.         if (n > 0) {
22.             sum = 1;
23.             int count = 0;
24.             for (int temp = 0, t = 0; n != count; ++count) {
25.                 t = sum;
26.                 sum += temp;
27.                 temp = t;
28.             }
29.         }
30.         return sum;
31.     }
33.     public static void main(String[] args) {
34.         long startTime = 0;
35.         long endTime = 0;
36.         int result = 0;
38.         System.out.println("递归的拙劣算法/n---------------------/n");
39.         System.out.println("使用递归算法：");
40.         startTime = System.currentTimeMillis();
41.         result = DiGv.fibonacci_1(NUMBER);
42.         endTime = System.currentTimeMillis();
43.         System.out.println("时间差：" + (endTime - startTime) + "/t计算结果：" + result);
45.         System.out.println();
46.         System.out.println("使用非递归算法：");
47.         startTime = System.currentTimeMillis();
48.         result = DiGv.fibonacci_2(NUMBER);
49.         endTime = System.currentTimeMillis();
50.         System.out.println("时间差：" + (endTime - startTime) + "/t计算结果：" + result);
51.     }
52. }

当NUMBER = 43时，运行的结果为：

递归的拙劣算法
---------------------

使用递归算法：
时间差：5641        计算结果：701408733

使用非递归算法：
时间差：0        计算结果：701408733

这些结果是在我的电脑配置下的结果，不同电脑的结果不同，但通过对比仍可显而易见。