算法笔记_001:斐波那契数的多种解法（Java）
2024-05-26 19:21:44
本篇文章解决的问题来源于算法设计与分析课程的课堂作业，主要是运用多种方法来计算斐波那契数。具体问题及解法如下：
一、问题1：
问题描述：利用迭代算法寻找不超过编程环境能够支持的最大整数的斐波那契数是第几个斐波那契数。（Java： 231-1 for int, 263-1 for long）
解决方案：针对问题1，此处要使用迭代法来解决，具体实现代码如下：
//用迭代法寻找编程环境支持的最大整数(int型)的斐波那契数是第几个斐波那契数public static int max_int_iteration(){int a = 1,b = 1,c = 2;int count = 3;for( ;b < c; ){ //一旦c达到编程环境最大斐波那契数，便会产生内存溢出，从而变成一个负数，到此循环结束a = b;b = c;c = a + b;count++;}return count;}//用迭代法寻找编程环境支持的最大整数(long型)的斐波那契数是第几个斐波那契数public static long max_long_iteration(){long a = 1,b = 1,c = 2;long count = 3;for( ;b<c; ){ //一旦c达到编程环境最大斐波那契数，便会产生内存溢出，从而变成一个负数，到此循环结束a = b;b = c;c = a + b;count++;}return count;}二、问题2：
问题描述：根据问题1中计算的最大的斐波那契数序号n，采用递归方式计算第n个斐波那契数，看其是否可以在3分钟内完成。
解决方案：针对问题2，此处要使用递归法来解决，问题1实际运行结果为：支持的最大整数（int型）值为47，支持的最大整数（long型）值为93。使用递归法计算第47个斐波那契数实际所需时间为138秒左右（此处本人使用WIN7系统运行所得），具体实现代码如下：
//递归法public static long recursion(long n){long result = 0; //最后一个斐波那契数及存储中间斐波那契数的变量if(n <= 0)result = 0;if(n == 1 || n == 2)result = 1;if(n > 2){result = recursion(n-1) + recursion(n-2);//System.out.print(result+" ");
}return result;}
//具体实现就只需使用System.currentTimeMillis()方法获取系统当前时间，就可以你计算出计算第47个斐波那契数所需时间三、问题3
问题描述：利用递归算法计算你的计算机能够在1，5，10，50秒内计算出的最大斐波那契数是第几个，利用迭代算法求解同样的问题。
解决方案：针对问题3，此处先要了解获得系统当前时间的相关方法及用法，然后计算规定时间内计算出的最大斐波那契数就很简单啦，具体实现代码如下：
//在1，5，10，50秒内使用迭代法算出的最大斐波那契数是第几个public static void time_iteration(){int a = 1,b = 1,c = 2;long count = 3;long a1 = 0,a2 = 0,a3 = 0,a4 = 0;long t1 = System.currentTimeMillis(); long t2 = System.currentTimeMillis();for( ;t2-t1 < 60000; ){ a = b;b = c;c = a + b;count++;t2 = System.currentTimeMillis(); if(t2-t1 == 1000)a1 = count;//System.out.println("1秒内最大斐波那契数是第："+count+"个 ");if(t2-t1 == 5000)a2 = count;//System.out.println("5秒内最大斐波那契数是第："+count+"个 ");if(t2-t1 == 10000)a3 = count;//System.out.println("10秒内最大斐波那契数是第："+count+"个 ");if(t2-t1 == 50000)a4 = count;//System.out.println("50秒内最大斐波那契数是第："+count+"个 ");
}System.out.println("迭代法1秒内最大斐波那契数是第："+a1+"个 ");System.out.println("迭代法5秒内最大斐波那契数是第："+a2+"个 ");System.out.println("迭代法10秒内最大斐波那契数是第："+a3+"个 ");System.out.println("迭代法50秒内最大斐波那契数是第："+a4+"个 ");}//递归法public static long recursion(long n){long result = 0; //最后一个斐波那契数及存储中间斐波那契数的变量if(n <= 0)result = 0;if(n == 1 || n == 2)result = 1;if(n > 2){result = recursion(n-1) + recursion(n-2);//System.out.print(result+" ");
}return result;}//规定时间内，递归法计算出的最大斐波那契数是第几个public static int recursion_time(long time){long starttime_dg=System.currentTimeMillis();int i=3;long endtime_dg=0;while(endtime_dg<starttime_dg+time*1000){endtime_dg=System.currentTimeMillis();i++;recursion(i);}return i;}//递归法在1，5，10，50秒内算出的最大斐波那契数是第几个public static void fbnq_recursion_time(){System.out.println("1秒内最大斐波那契数是第："+recursion_time(1)+"个 ");System.out.println("5秒内最大斐波那契数是第："+recursion_time(5)+"个 ");System.out.println("10秒内最大斐波那契数是第："+recursion_time(10)+"个 ");System.out.println("50秒内最大斐波那契数是第："+recursion_time(50)+"个 ");}四、问题4
问题描述：利用公式F(n) = [fn/sqrt(5)]快速计算第n个斐波那契数，找出出现误差时的最小n值。其具体公式描述见下图：
解决方案：针对问题4，只需要将上述公式用代码来描述就可以完成，具体实现代码如下：
//直接求值法（利用公式F(n) = [@n/sqrt(5)]快速计算第n个斐波那契数）public static double formula(int n){double result = 0;double temp = Math.sqrt(5.0);result = (1/temp)*(Math.pow((1+temp)/2,n)-Math.pow((1-temp)/2, n));return result;}五、问题5
问题描述：利用矩阵相乘方法计算第n个斐波那契数。
解决方案：对于矩阵相乘法，首先得对矩阵相乘的法则要熟悉，现简单说明一下矩阵相乘求斐波那契数的思想及原理：
（1）矩阵定义
设A为
mxp的矩阵，B为
pxn的矩阵，那么称
mxn
的矩阵C为矩阵A与B的乘积，记作
C =AB，其中矩阵C中的第
i行第
j列元素可以表示为：
如下所示：
（2）矩阵相乘求斐波那契数原理
数列的递推公式为：f(1)=1，f(2)=1，f(3)=2 , f(n)=f(n-1)+f(n-2)(n>=3)用矩阵表示为：
进一步，可以得出直接推导公式：
具体实现代码如下：
// 关联矩阵 private static final int[][] UNIT = { { 1, 1 }, { 1, 0 } }; //定义一个上面公式中需要计算的二维数组// 全0矩阵 private static final int[][] ZERO = { { 0, 0 }, { 0, 0 } }; //定义一个元素均为0的二维数组/** * 求斐波那契数列 * * @param n * @return */ public static int[][] fb(int n) { if (n == 0) { //指数n为0时返回该数组return ZERO; } if (n == 1) { //指数n为1时返回该数组return UNIT; } // n是偶数 if ((n & 1) == 0) { //把（n&1） == 0换成（n%2） == 0等价 ， 唯一区别在于（n&1） == 0计算效率高int[][] matrix = fb(n >> 1); //n >> 1意思是指将n的二进制数向右移动1位，最高位补0。相当于把n除以2 return matrixMultiply(matrix, matrix); } // n是奇数 int[][] matrix = fb((n - 1) >> 1); return matrixMultiply(matrixMultiply(matrix, matrix), UNIT); } /** * 矩阵相乘 * * @param m * r1*c1 * @param n * c1*c2 * @return 新矩阵,r1*c2 */ public static int[][] matrixMultiply(int[][] m, int[][] n) { int rows = m.length; int cols = n[0].length; int[][] r = new int[rows][cols]; for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { r[i][j] = 0; for (int k = 0; k < m[i].length; k++) { r[i][j] += m[i][k] * n[k][j]; } } } return r; } //具体实现矩阵相乘算法public static int matrix(int n){int[][] m = fb(n); return m[0][1];}六、问题6
问题描述：对于相同的输入n值，比较上述四种方法的基本操作次数，以掌握对数、线性和指数增长率的极大差别。
解决方案：此处本人只是把上述所用的四种方法运行了一遍，计算各个相应方案计算第n个斐波那契数所花时间，因为具体算法相应的基本操作次数，用代码来计算有点麻烦，所以此处就不罗列了。
七、新算法法
这是解决斐波那契数的一种新算法，该算法的时间和空间效率都优于上面四种算法，该算法所用公式如下图所示：
具体实现代码如下：
//新算法法public static int new_way(int n){//int a = 1,b = 1,c = 2,d = 3;int result = 0; //定义最后一个斐波那契数//根据输入n,求出最后一个斐波那契数if(n == 0)result = 0;else if(n == 1 || n == 2)result = 1;else if(n == 3)result = 2;else if(n >= 4){ //若n大于4返回resulint a1 = n/4;int b1 = n%4;int a = new_way(a1);int b = new_way((a1+1));int c = new_way((a1-1));int d = new_way((a1+2));if(b1 == 0)result = (int) ((Math.pow(b,2) - Math.pow(c,2))*(Math.pow(c, 2) + 2*Math.pow(a, 2) + Math.pow(b,2)));if(b1 == 1)result = (int) (Math.pow((Math.pow(b,2) - Math.pow(c,2)),2) + Math.pow((Math.pow(a, 2) + Math.pow(b,2)),2));if(b1 == 2)result = (int) ((Math.pow(a, 2) + Math.pow(b,2))*(3*Math.pow(b,2)+Math.pow(a, 2)-2*Math.pow(c,2)));if(b1 == 3)result = (int) (Math.pow((Math.pow(a, 2) + Math.pow(b,2)),2) + Math.pow((Math.pow(d,2)-Math.pow(a,2)),2));}return result;}八、具体类运行实现
代码如下：
1 package com.liuzhen.ex_one;
2
3 public class Fibonacci {
4
5 //迭代法
6 public static int iteration(int n){ /*此处(包含下面所有方法)声明为静态方法，原因是在本类main()方法中调用
7 类中方法,对于一般的非static成员变量或方法，需要有一个对象的实例才能调用，所以要先生成对象的实例，他们才会实际的分配内存空间。
8 而对于static的对象或方法，在程序载入时便已经分配了内存空间，他只和特定的类想关联，无需实例化 */
9 int result = 1; //最后一个斐波那契数
10 int a[] = new int[n+1]; //存放斐波那契数，初始值为空，默认全为0
11 a[0] = 0;
12 a[1] = 1;
13 //System.out.println("迭代法计算斐波那契数结果：");
14 //System.out.print(a[0]+" "+a[1]+" ");
15 for(int i = 2;i < n+1;i++){
16 a[i] = a[i-1] + a[i-2];
17 //result = a[i];
18 //System.out.print(result+" "); //打印斐波那契数
19 }
20 //System.out.println();
21 result=a[n];
22 return result; //返回最后一个斐波那契数
23 }
24
25 //用迭代法寻找编程环境支持的最大整数(int型)的斐波那契数是第几个斐波那契数
26 public static int max_int_iteration(){
27 int a = 1,b = 1,c = 2;
28 int count = 3;
29 for( ;b < c; ){ //一旦c达到编程环境最大斐波那契数，便会产生内存溢出，从而变成一个负数，到此循环结束
30 a = b;
31 b = c;
32 c = a + b;
33 count++;
34 }
35 return count;
36 }
37
38
39 //用迭代法寻找编程环境支持的最大整数(long型)的斐波那契数是第几个斐波那契数
40 public static long max_long_iteration(){
41 long a = 1,b = 1,c = 2;
42 long count = 3;
43 for( ;b<c; ){ //一旦c达到编程环境最大斐波那契数，便会产生内存溢出，从而变成一个负数，到此循环结束
44 a = b;
45 b = c;
46 c = a + b;
47 count++;
48 }
49 return count;
50 }
51
52 //在1，5，10，50秒内使用迭代法算出的最大斐波那契数是第几个
53 public static void time_iteration(){
54 int a = 1,b = 1,c = 2;
55 long count = 3;
56 long a1 = 0,a2 = 0,a3 = 0,a4 = 0;
57 long t1 = System.currentTimeMillis();
58 long t2 = System.currentTimeMillis();
59 for( ;t2-t1 < 60000; ){
60 a = b;
61 b = c;
62 c = a + b;
63 count++;
64 t2 = System.currentTimeMillis();
65 if(t2-t1 == 1000)
66 a1 = count;
67 //System.out.println("1秒内最大斐波那契数是第："+count+"个 ");
68 if(t2-t1 == 5000)
69 a2 = count;
70 //System.out.println("5秒内最大斐波那契数是第："+count+"个 ");
71 if(t2-t1 == 10000)
72 a3 = count;
73 //System.out.println("10秒内最大斐波那契数是第："+count+"个 ");
74 if(t2-t1 == 50000)
75 a4 = count;
76 //System.out.println("50秒内最大斐波那契数是第："+count+"个 ");
77 }
78 System.out.println("迭代法1秒内最大斐波那契数是第："+a1+"个 ");
79 System.out.println("迭代法5秒内最大斐波那契数是第："+a2+"个 ");
80 System.out.println("迭代法10秒内最大斐波那契数是第："+a3+"个 ");
81 System.out.println("迭代法50秒内最大斐波那契数是第："+a4+"个 ");
82 }
83
84 //递归法
85 public static long recursion(long n){
86 long result = 0; //最后一个斐波那契数及存储中间斐波那契数的变量
87 if(n <= 0)
88 result = 0;
89 if(n == 1 || n == 2)
90 result = 1;
91 if(n > 2)
92 {
93 result = recursion(n-1) + recursion(n-2);
94 //System.out.print(result+" ");
95 }
96 return result;
97 }
98
99 //规定时间内，递归法计算出的最大斐波那契数是第几个
100 public static int recursion_time(long time){
101 long starttime_dg=System.currentTimeMillis();
102 int i=3;
103 long endtime_dg=0;
104 while(endtime_dg<starttime_dg+time*1000){
105 endtime_dg=System.currentTimeMillis();
106 i++;
107 recursion(i);
108 }
109 return i;
110 }
111
112 //递归法在1，5，10，50秒内算出的最大斐波那契数是第几个
113 public static void fbnq_recursion_time(){
114
115 System.out.println("1秒内最大斐波那契数是第："+recursion_time(1)+"个 ");
116
117 System.out.println("5秒内最大斐波那契数是第："+recursion_time(5)+"个 ");
118
119 System.out.println("10秒内最大斐波那契数是第："+recursion_time(10)+"个 ");
120
121 System.out.println("50秒内最大斐波那契数是第："+recursion_time(50)+"个 ");
122
123
124 }
125
126 //测试递归法在1，5，10，50秒内使用迭代法算出的最大斐波那契数是第几个
127 public static void time_recursion_test(){
128 long t1 = System.currentTimeMillis();
129 long t2 = 0;
130 int i = 3;
131 for(;t2-t1 > 60000;){
132 recursion(i);
133 i++;
134 t2 = System.currentTimeMillis();
135 if(t2-t1 == 1000)
136 System.out.println("1秒内最大斐波那契数是第："+i+"个 ");
137 if(t2-t1 == 5000)
138 System.out.println("5秒内最大斐波那契数是第："+i+"个 ");
139 if(t2-t1 == 10000)
140 System.out.println("10秒内最大斐波那契数是第："+i+"个 ");
141 if(t2-t1 == 50000)
142 System.out.println("50秒内最大斐波那契数是第："+i+"个 ");
143
144 }
145 }
146
147 //直接求值法（利用公式F(n) = [@n/sqrt(5)]快速计算第n个斐波那契数）
148 public static double formula(int n){
149 double result = 0;
150 double temp = Math.sqrt(5.0);
151 result = (1/temp)*(Math.pow((1+temp)/2,n)-Math.pow((1-temp)/2, n));
152 return result;
153 }
154
155
156 //利用直接求值法，出现误差时最小的n值
157 public static int min_formula(){
158 double result_fn=1;
159 int i=1;
160 while(result_fn-(double)iteration(i)<1){
161 result_fn=formula(i);
162 i++;
163 }
164 return i;
165 }
166
167 //新算法法
168 public static int new_way(int n){
169 //int a = 1,b = 1,c = 2,d = 3;
170 int result = 0; //定义最后一个斐波那契数
171 //根据输入n,求出最后一个斐波那契数
172 if(n == 0)
173 result = 0;
174 else if(n == 1 || n == 2)
175 result = 1;
176 else if(n == 3)
177 result = 2;
178 else if(n >= 4){ //若n大于4返回resul
179 int a1 = n/4;
180 int b1 = n%4;
181 int a = new_way(a1);
182 int b = new_way((a1+1));
183 int c = new_way((a1-1));
184 int d = new_way((a1+2));
185 if(b1 == 0)
186 result = (int) ((Math.pow(b,2) - Math.pow(c,2))*(Math.pow(c, 2) + 2*Math.pow(a, 2) + Math.pow(b,2)));
187 if(b1 == 1)
188 result = (int) (Math.pow((Math.pow(b,2) - Math.pow(c,2)),2) + Math.pow((Math.pow(a, 2) + Math.pow(b,2)),2));
189 if(b1 == 2)
190 result = (int) ((Math.pow(a, 2) + Math.pow(b,2))*(3*Math.pow(b,2)+Math.pow(a, 2)-2*Math.pow(c,2)));
191 if(b1 == 3)
192 result = (int) (Math.pow((Math.pow(a, 2) + Math.pow(b,2)),2) + Math.pow((Math.pow(d,2)-Math.pow(a,2)),2));
193
194 }
195 return result;
196 }
197
198
199 // 关联矩阵
200 private static final int[][] UNIT = { { 1, 1 }, { 1, 0 } };
201 // 全0矩阵
202 private static final int[][] ZERO = { { 0, 0 }, { 0, 0 } };
203 /**
204 * 求斐波那契数列
205 *
206 * @param n
207 * @return
208 */
209 public static int[][] fb(int n) {
210 if (n == 0) {
211 return ZERO;
212 }
213 if (n == 1) {
214 return UNIT;
215 }
216 // n是奇数
217 if ((n & 1) == 0) {
218 int[][] matrix = fb(n >> 1);
219 return matrixMultiply(matrix, matrix);
220 }
221 // n是偶数
222 int[][] matrix = fb((n - 1) >> 1);
223 return matrixMultiply(matrixMultiply(matrix, matrix), UNIT);
224 }
225
226 /**
227 * 矩阵相乘
228 *
229 * @param m
230 * r1*c1
231 * @param n
232 * c1*c2
233 * @return 新矩阵,r1*c2
234 */
235 public static int[][] matrixMultiply(int[][] m, int[][] n) {
236 int rows = m.length;
237 int cols = n[0].length;
238 int[][] r = new int[rows][cols];
239 for (int i = 0; i < rows; i++) {
240 for (int j = 0; j < cols; j++) {
241 r[i][j] = 0;
242 for (int k = 0; k < m[i].length; k++) {
243 r[i][j] += m[i][k] * n[k][j];
244 }
245 }
246 }
247 return r;
248 }
249
250 //具体实现矩阵相乘算法
251 public static int matrix(int n){
252 int[][] m = fb(n);
253 return m[0][1];
254 }
255
256 public static void main(String[] args){
257 System.out.print(max_int_iteration());
258 System.out.println();
259 System.out.print(max_long_iteration());
260 System.out.println();
261 System.out.println();
262 long t1 = System.currentTimeMillis();
263 long a = recursion(47);
264 long t2 = System.currentTimeMillis();
265 System.out.println("递归法求斐波那契数：");
266 System.out.println(a);
267 System.out.println("递归算法Time is: " + (t2 - t1)/1000.0+"秒");
268
269 //此处下面可以直接通过给相关类传递参数，实现相应功能，上面的中代码仅仅提供示例
270 }
271
272 }View Code
PS：运行部分结果截图
对于本问题，我自己用安卓做了一个简单的展示界面（具体介绍请参考我的另一篇博客：用安卓实现斐波那契数和最近点对问题）：
参考资料：
1、斐波那契数列解析
2、斐波那契数列的矩阵解法(java实现)
转载于:https://www.cnblogs.com/liuzhen1995/p/6014322.html
算法笔记_001:斐波那契数的多种解法（Java）相关推荐
- 求第 N 个 斐波那契数的多种方法
斐波那契数列 是一个非常美丽.和谐的数列,也是一个黄金分割数列.符合黄金分割比0.618.有人说它起源于一对繁殖力惊人.基因非常优秀的兔子,也有人说远古时期的鹦鹉就知道这个规律. 斐波那契数列 ...
- 【js算法】js斐波那契数列的多种算法
斐波那契数列(Fibonacci sequence),又称黄金分割数列,因数学家莱昂纳多·斐波那契(Leonardo Fibonacci)以兔子繁殖为例子而引入,故又称为"兔子数列" ...
- [算法学习]斐波那契数的计算
决定开始看algorithms,而且尽量多思考,多写点代码.第一个碰到的算法就很具有启发性,一些看似正确的算法,实际的复杂度却很高.我们直接看问题: 问题:假设fibonacci(0)=0,fibon ...
- JavaScript实现闭式函数计算特定位置的斐波那契数fibonacciNthClosedForm算法（附完整源码）
JavaScript实现闭式函数计算特定位置的斐波那契数fibonacciNthClosedForm算法(附完整源码) fibonacciNthClosedForm.js完整源代码 fibonacci ...
- JavaScript实现动态规划方法计算特定位置的斐波那契数fibonacciNth算法（附完整源码）
JavaScript实现动态规划方法计算特定位置的斐波那契数fibonacciNth算法(附完整源码) fibonacciNth.js完整源代码 fibonacciNth.js完整源代码 export ...
- 在计算机科学中算法指的是,算法 - 为什么斐波纳契数在计算机科学中具有重要意义？...
算法 - 为什么斐波纳契数在计算机科学中具有重要意义? Fibonacci数字已经成为计算机科学学生递归的一个流行的介绍,并且有一个强烈的论据,他们坚持在自然界. 出于这些原因,我们很多人都熟悉它们. ...
- 力扣算法 509. 斐波那契数 70. 爬楼梯 746. 使用最小花费爬楼梯
学习内容 力扣算法 509. 斐波那契数 70. 爬楼梯 746. 使用最小花费爬楼梯 具体内容 509. 斐波那契数 斐波那契数,通常用 F(n) 表示,形成的序列称为 斐波那契数列 .该数列由 0 ...
- 算法----斐波那契数
題目 斐波那契数 斐波那契数,通常用 F(n) 表示,形成的序列称为 斐波那契数列 .该数列由 0 和 1 开始,后面的每一项数字都是前面两项数字的和.也就是: F(0) = 0,F(1) = 1 F ...
- 算法实验1、用C/C++编写递归函数，计算斐波那契数（Fibonacci）Fn
我们设第n个斐波那契数为F(n),根据斐波那契数列的定义,有: 1)当n<=2,F(n)=1: 2)当n>2,F(n)=F(n-1)+F(n-2). 那么在我们进行递归编程的时候,可以: ...
最新文章
- 西游记里河水让人怀孕的秘密：是寄生虫！我往河里放了寄生虫！
- 【Jekyll搭建GITHUB个人博客】安装Ruby 环境、包管理器 RubyGems、Jekyll与错误解决...
- Python学习之==数组（一）
- webService的简单使用
- CF876 F 思维 枚举
- 助力泵嗡嗡响解决方法_突破不可能，3D打印革命性的制造高效高扭矩的径向活塞泵...
- 准备学习研究一下语音识别 请问有哪些值得推荐的书籍 论文 及开源库？
- 计算机二级c语言考试真题及答案详解,全国计算机二级c语言考试题
- vue使用插件jsbarcode 生成条码下载
- html语言文本框怎么做,HTML文本框参考样式
- 计算机科学相关的期刊,计算机类期刊汇总（核心期刊，国家级期刊）
- 2016 安全行业全景图——By 安全牛
- hdu5651xiaoxin juju needs help（大组合数模板）
- C# 无损压缩图片
- k8s containerd集群配置安装完整踩坑教程
- Java项目：ssm教务管理系统
- AceEditor使用小结
- 线性代数之 向量空间几何学（1）仿射
- Cisco 第3章 基本网络连接和通信 测试考试答案
- 2023-2028年中国合成氨行业发展前景与投资规划分析报告
热门文章
- 【跨平台网络抓包神器のtcpdump】ubuntu下编译tcpdump开源抓包工具
- 数据结构与算法 -- 时间复杂度
- 百度地图相关问题总结
- BINDER SECCTX PATCH ANALYSIS
- Introduction to Byteball — Part 4: Adoption
- DeepBrain 李传丰：当语义技能商店应用达到百万量级的时候，语音交互时代才会真正成熟 | WARE 2017
- 对深度学习的逃逸攻击 — 探究人工智能系统中的安全盲区
- JZOJ 5286. 【NOIP2017提高A组模拟8.16】花花的森林
- BZOJ 3740. 【TJOI2014】电源插排
- linux查看网卡传输,Linux下查看网卡实时流量工具