斐波拉契数列 Java三种实现

对于很多Java初学者来说，求解斐波拉契数列，基本上所使用的方式都是递归。对于求解斐波拉契数列来说，递归的实现方式的效率是极其低下的。

 

在此，我贴出三种实现（递归，迭代，动态规划）：

我们先看代码的执行效果：

再看代码实现：

package com.aura.funny.fibonacci;

import java.util.HashMap;
import java.util.Map;

/**
 * 作者： 马中华   https://blog.csdn.net/zhongqi2513
 * 时间： 2019/6/10 13:45
 * 描述：
 *          斐波拉契数列的三种不同求解方式
 *          效率截然不一样
 */
public class Fibonacci {

    static Map<String, Long> context = new HashMap<String, Long>();

    static{
        context.put("f1", 1L);
        context.put("f2", 1L);
    }

    public static void main(String[] args) {

        long n = 50;
        System.out.println("求解斐波拉契数列的第"+n+"项：");


        // 递归
        long start1 = System.nanoTime();
        System.out.println(fibonacci1(n));
        long end1 = System.nanoTime();
        System.out.println("递归        消耗总时间：" + (end1 - start1) + "ns");


        // 动态规划
        long start2 = System.nanoTime();
        System.out.println(fibonacci2(n));
        long end2 = System.nanoTime();
        System.out.println("动态规划    消耗总时间：" + (end2 - start2) + "ns");


        // 迭代
        long start3 = System.nanoTime();
        System.out.println(fibonacci3(n));
        long end3 = System.nanoTime();
        System.out.println("迭代实现    消耗总时间：" + (end3 - start3) + "ns");
    }


    // 递归实现
    public static long fibonacci1(long n){
        if(n == 1){
            return 1;
        }else if(n == 2){
            return 1;
        }else{
            return fibonacci1(n-1) + fibonacci1(n - 2);
        }
    }


    // 动态规划实现
    public static long fibonacci2(long n){

        String key = "f" + n;
        if(context.containsKey(key)){
            return context.get(key);
        }else{
            // 获取前两个，或者算
            String key1 = "f" + (n - 1);
            String key2 = "f" + (n - 2);

            long value1 = 0;
            long value2 = 0;

            if(context.containsKey(key1)){
                value1 = context.get(key1);
            }else{
                value1 = fibonacci2(n - 1);
                context.put(key1, value1);
            }

            if(context.containsKey(key2)){
                value2 = context.get(key2);
            }else{
                value2 = fibonacci2(n - 2);
                context.put(key2, value2);
            }

            return value1 + value2;
        }
    }


    // 迭代实现
    public static long fibonacci3(long n){
        // 使用迭代算法
        long f1 = 1;
        long f2 = 1;
        long f3 = 0;

        if(n == 1 || n == 2){
            return 1;
        }else{
            for(int i = 2; i < n; i++){
                f3 = f1 + f2;
                f1 = f2;
                f2 = f3;
            }
            return f3;
        }
    }
}

希望大家在写代码的时候，除了关注业务功能的实现，还要关注代码的执行效率。