java优化递归求斐波那契数列

优化递归求斐波那契数列

斐波那契数列在我们递归学习中是一个基本的算法。今天我们也学习了递归，也做了关于求斐波那契第n项的算法，发现普通的递归斐波那契的计算效率很局限，在第50项左右都很吃力了，对此我又对斐波那契递归做了优化，发现效果特别好，特来次分享！

首先来看看普通的递归算法

public static long fid(long n){
	if(n==1 || n==2) return 1;
	else return fid(n-2)+fid(n-1);
}

这个算法仔细分析分析会发现他的时间复杂度会随着n的增加会成指数上升，导致在50左右计算机算起来就很吃力了！！！其原因在于算前一项所用的n-1，在算后一项所用的n-2递归计算了两次，从而增加了其复杂度

再来看看优化后的递归算法

public static long  better_fid(int n, long result[], int len){
	len++;
	if(n==1) return 0;
	if(n>=2) result[len]=result[len-1]+result[len-2];
	return better_fid(n-1,result,len);
}

public static void better_fid_test(){
	long result[] = new long[200];
	result[0]=1;
	result[1]=1;
	int len = 1;
	System.out.println();
	System.out.println("开始进行优化后的斐波那契测试");
	System.out.println("输入>=2的数：");
	int n = sc.nextInt();
	long start=System.nanoTime();
	better_fid(n,result,len);
	long after=System.nanoTime();
	System.out.println("第"+n+"个斐波那契数为："+result[n-1]);
	System.out.println("优化后的斐波那契的时间为5"+(after-start)+"纳秒");
}

这个算法在我测试的时候发现，在n=15左右之前，比普通的递归要高，而它在n>15后，运算效果就非常好了，在n=100也是非常快的计算出来！

测试

package recurrence;
import java.util.Scanner;

public class recurrence {

private static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
	fid_test();
	better_fid_test();
}


public static long fid(long n){
	if(n==1 || n==2) return 1;
	else return fid(n-2)+fid(n-1);
}

public static void fid_test(){
	System.out.println("开始进行斐波那契测试");
	System.out.println("输入>=2的数：");
	long n = sc.nextLong();
	long start=System.nanoTime();
	long result = fid(n);
	long after=System.nanoTime();
	System.out.println("第"+n+"个斐波那契数为："+result);
	System.out.println("优化后的斐波那契的时间为"+(after-start)+"纳秒");
}


public static long  better_fid(int n, long result[], int len){
	len++;
	if(n==1) return 0;
	if(n>=2) result[len]=result[len-1]+result[len-2];
	return better_fid(n-1,result,len);
}

public static void better_fid_test(){
	long result[] = new long[200];
	result[0]=1;
	result[1]=1;
	int len = 1;
	System.out.println();
	System.out.println("开始进行优化后的斐波那契测试");
	System.out.println("输入>=2的数：");
	int n = sc.nextInt();
	long start=System.nanoTime();
	better_fid(n,result,len);
	long after=System.nanoTime();
	System.out.println("第"+n+"个斐波那契数为："+result[n-1]);
	System.out.println("优化后的斐波那契的时间为5"+(after-start)+"纳秒");
}

}

这里的数据就非常明显了！！！