java-算法Fibonacci序列

一.递归的方法

import java.util.Scanner;  
public class Fibonacci{   
    public static void main(String[] args) {  
            Scanner sc = new Scanner(System.in);  
            System.out.println("请输入一个大于零的整数：");  
            int n = sc.nextInt();  
            System.out.println("斐波那契数列为：");  
            for (int j = 0; j <= n; j++) {  
                System.out.print(fibonacci(j)+"  ");  
            }  
            //sc.close();  
        }   
        private static int fibonacci(int n) {
            if(n==0)
            {
                return 0;
            }else if(n==1||n==2)
            {
                return 1;
            }
            else if(n>2)
            {
                int temp=fibonacci(n-1)+fibonacci(n-2);
                return temp;
            }
            return n;
        }  

    }  

此种方式缺点：大量迭代不断消耗栈空间(搞web开发调试维护的都应该知道服务器栈资源的可贵，如果大量并发调用迭代导致服务器栈资源迟迟得不到回收，而导致web服务器崩溃)，效率底，函数自闭性比较弱(优秀的接口应该对输入输出可能出现的错误信息进行捕捉，并提供清楚明了的处理结果)，很容易出现错误，调试困难，实际应用中一般不建议使用这种方式，使用时迭代次数也不能超过3次；
二.时间换空间

import java.util.Scanner;  
public class Fibonacci{   
    public static void main(String[] args) {  
            Scanner sc = new Scanner(System.in);  
            System.out.println("请输入一个大于零的整数：");  
            int n = sc.nextInt();  
            System.out.println("斐波那契数列为：");  
            for (int j = 0; j <= n; j++) {  
                System.out.print(fibonacci(j)+"  ");  
            }  
        }   
        private static int fibonacci(int n) {

            int result=-1;
            int temp1=0;
            int temp2=1;
            for(int index=0;index<=n;index++){
            if(index==0)
            {
            result=temp1;
            }else if(index==1)
            {
            result=temp2;      
            }else{
                    result=temp1+temp2;
                    if(result<0){
                     result=-2;
                     break;
                    }
                    temp1=temp2;
                    temp2=result;
                   }
                  }
                  return result;
        }  

    } 

此方法主要使用于:使用场景一：对于对象或变量使用次数比较少，使用一次以后就不会再使用的场景；使用场景二：对于内存资源比较稀缺的实时性要求不是太高的嵌入式系统设计中多会采用此种方式；
三.空间换时间
此方法一般用于：对象或变量在程序运行的整个生命周期都存在或频繁调用的场景，如调用外部WebService接口、抽象持续化层、常用配置文件参数加载等等。

import java.util.ArrayList;
import java.util.List;

public class Fibonacci {
     private static List<Integer> fnData=new ArrayList<Integer>();
     private static final int maxSize=50000;
     /**
      * 初始化器
      */
     private static void setFnData(){
      int result=-1;
      int temp1=0;
      int temp2=1;
      for(int index=0;index<=maxSize;index++){
       if(index==0){
        result=temp1;
       }else if(index==1){
        result=temp2;
       }else{
        result=temp1+temp2;
        if(result<0){
         result=-2;
         break;
        }
        temp1=temp2;
        temp2=result;
       }
       fnData.add(result);
      }
     }
     /**
      * 对外接口
      */
     public int getFnData(int n){
      if(fnData.size()==0){
       setFnData();
      }
      if(fnData.size()>n&&n>=0){
       return fnData.get(n);
      }else{
       return -1;
      }
     }
     public static void main(String[] argv){
         Fibonacci init=new Fibonacci();
          int n=8;
          for(int i=0;i<=n;i++)
          System.out.print (init.getFnData(i)+"  ");
         }
        }

四.数组的方法实现

    public class Fibonacci_1{
    public static void main(String[] args) {  
      int[] is = f(10);  
      for(int i : is)  
       System.out.print(" "+i);  
     }  

     // 输入长度，得到数组  
     public static int[] f(int length) {  
      if (length < 2)  
       return null;  
      int[] fs = new int[length];  
      fs[0] = 1;  
      fs[1] = 1;  
      for (int i = 2; i < length; i++) {  
       fs[i] = fs[i-1] + fs[i-2];  
      }  

      return fs;  
     }  
     }