[MC源码] 斐波那契数列（Fibonacci sequence）研究 斐波那契数列, Fibonacci

斐波那契数列（Fibonacci sequence），又称黄金分割数列，因数学家莱昂纳多·斐波那契（Leonardo Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用，为此，美国数学会从 1963 年起出版了以《斐波纳契数列季刊》为名的一份数学杂志，用于专门刊载这方面的研究成果。

定义

斐波那契数列指的是这样一个数列：

下载 (8.39 KB)

2021-10-15 09:51

这个数列从第3项开始，每一项都等于前两项之和。
斐波那契数列的定义者，是意大利数学家莱昂纳多·斐波那契（Leonardo Fibonacci），生于公元1170年，卒于1250年，籍贯是比萨。他被人称作“比萨的莱昂纳多”。1202年，他撰写了《算盘全书》（Liber Abacci）一书。他是第一个研究了印度和阿拉伯数学理论的欧洲人。他的父亲被比萨的一家商业团体聘任为外交领事，派驻地点于阿尔及利亚地区，莱昂纳多因此得以在一个阿拉伯老师的指导下研究数学。他还曾在埃及、叙利亚、希腊、西西里和普罗旺斯等地研究数学。另外斐波纳契还在计算机C语言程序题中应用广泛

通项公式

递推公式

斐波那契数列：

下载 (4.78 KB)

2021-10-15 09:54

显然这是一个线性递推数列。

通项公式

⑴.

下载 (4.63 KB)

2021-10-15 09:55

(如上，又称为“比内公式”，是用无理数表示有理数的一个范例。)

注：此时

下载 (3.62 KB)

2021-10-15 09:56

⑵ an=[(2/√5+1)-1/(√5+1/2)ⁿ]/√5

通项公式推导

方法一：利用特征方程（线性代数解法）

线性递推数列的特征方程为：

下载 (16.85 KB)

2021-10-15 09:57

方法二：待定系数法构造等比数列1（初等代数解法）

下载 (48.55 KB)

2021-10-15 09:58

方法三：待定系数法构造等比数列（初等代数解法）

下载 (41.51 KB)

2021-10-15 09:59

方法四：母函数法。

下载 (49.48 KB)

2021-10-15 09:59

与黄金分割的关系

有趣的是，这样一个完全是自然数的数列，通项公式却是用无理数来表达的。而且当趋向于无穷大时，前一项与后一项的比值越来越逼近黄金分割0.618（或者说后一项与前一项的比值小数部分越来越逼近 0.618）。

下载 (17.45 KB)

2021-10-15 10:01

证明

下载 (12.83 KB)

2021-10-15 10:01

所以极限是黄金分割比。

特性

平方与前后项

从第二项开始（构成一个新数列，第一项为1，第二项为2，……），每个偶数项的平方都比前后两项之积多1，每个奇数项的平方都比前后两项之积少1。

如：第二项 1 的平方比它的前一项 1 和它的后一项 2 的积 2 少 1，第三项 2 的平方比它的前一项 1 和它的后一项 3 的积 3 多 1。

（注：奇数项和偶数项是指项数的奇偶，而并不是指数列的数字本身的奇偶，比如从数列第二项 1 开始数，第 4 项 5 是奇数，但它是偶数项，如果认为 5 是奇数项，那就误解题意，怎么都说不通）

下载 (2.59 KB)

2021-10-15 10:03

与集合子集

斐波那契数列的第n+2项同时也代表了集合

下载 (1.17 KB)

2021-10-15 10:05

中所有不包含相邻正整数的子集个数。

下载 (23.09 KB)

2021-10-15 10:05

应用

黄金分割

随着数列项数的增加，前一项与后一项之比越来越逼近黄金分割的数值 0.6180339887..…

杨辉三角

将杨辉三角左对齐，成图1所示排列，将同一斜行的数加起来，即得一数列 1、1、2、3、5、8、……

下载 (7.25 KB)

2021-10-15 10:10

公式表示如下：

下载 (18.23 KB)

2021-10-15 10:11

矩形面积

斐波那契数列与矩形面积的生成相关，由此可以导出一个斐波那契数列的一个性质。

下载 (116.75 KB)

2021-10-15 10:13

斐波那契数列前几项的平方和可以看做不同大小的正方形，由于斐波那契的递推公式，它们可以拼成一个大的矩形。这样所有小正方形的面积之和等于大矩形的面积。则可以得到如下的恒等式：

下载 (2.29 KB)

2021-10-15 10:12

质数数量

斐波那契数列的整除性与质数生成性

下载 (9.95 KB)

2021-10-15 10:14

每3个连续的数中有且只有一个被 2 整除，
每4个连续的数中有且只有一个被 3 整除，
每5个连续的数中有且只有一个被 5 整除，
每6个连续的数中有且只有一个被 8 整除，
每7个连续的数中有且只有一个被 13 整除，
每8个连续的数中有且只有一个被 21 整除，
每9个连续的数中有且只有一个被 34 整除，
.......
我们看到第5、7、11、13、17、23位分别是质数：5，13，89，233，1597，28657（第19位不是）

斐波那契数列的质数无限多吗？

尾数循环

斐波那契数列的个位数：一个60步的循环

11235,83145,94370,77415,61785,38190,
99875,27965,16730,33695,49325,72910…

进一步，斐波那契数列的最后两位数是一个300步的循环，最后三位数是一个1500步的循环，最后四位数是一个15000步的循环，最后五位数是一个150000步的循环。

自然界中“巧合”

斐波那契数列在自然科学的其他分支，有许多应用。例如，树木的生长，由于新生的枝条，往往需要一段“休息”时间，供自身生长，而后才能萌发新枝。所以，一株树苗在一段间隔，例如一年，以后长出一条新枝；第二年新枝“休息”，老枝依旧萌发；此后，老枝与“休息”过一年的枝同时萌发，当年生的新枝则次年“休息”。这样，一株树木各个年份的枝桠数，便构成斐波那契数列。这个规律，就是生物学上著名的“鲁德维格定律”。

下载 (15.98 KB)

2021-10-15 10:17

另外，观察延龄草、野玫瑰、南美血根草、大波斯菊、金凤花、耧斗菜、百合花、蝴蝶花的花瓣，可以发现它们花瓣数目具有斐波那契数：3、5、8、13、21……

其中百合花花瓣数目为 3，梅花 5 瓣，飞燕草 8 瓣，万寿菊 13 瓣，向日葵 21 或 34 瓣，雏菊有 34、55 和 89 三个数目的花瓣。

斐波那契螺旋：具有 13 条顺时针旋转和 21 条逆时针旋转的螺旋的蓟的头部

这些植物懂得斐波那契数列吗？应该并非如此，它们只是按照自然的规律才进化成这样。这似乎是植物排列种子的“优化方式”，它能使所有种子具有差不多的大小却又疏密得当，不至于在圆心处挤了太多的种子而在圆周处却又稀稀拉拉。叶子的生长方式也是如此，对于许多植物来说，每片叶子从中轴附近生长出来，为了在生长的过程中一直都能最佳地利用空间（要考虑到叶子是一片一片逐渐地生长出来，而不是一下子同时出现的），每片叶子和前一片叶子之间的角度应该是 222.5°，这个角度称为“黄金角度”，因为它和整个圆周 360° 之比是黄金分割数0.618033989……的倒数，而这种生长方式就决定了斐波那契螺旋的产生。向日葵的种子排列形成的斐波那契螺旋有时能达到 89，甚至 144 条。1992 年，两位法国科学家通过对花瓣形成过程的计算机仿真实验，证实了在系统保持最低能量的状态下，花朵会以斐波那契数列长出花瓣。

数字谜题

三角形的三边关系定理和斐波那契数列的一个联系：

现有长为 144 cm 的铁丝，要截成n小段（n>2），每段的长度不小于 1 cm，如果其中任意三小段都不能拼成三角形，则n的最大值为多少？

分析：由于形成三角形的充要条件是任何两边之和大于第三边，因此不构成三角形的条件就是存在两边之和不超过另一边。截成的铁丝最小为 1，因此可以放 2 个 1，第三条线段就是 2（为了使得n最大，因此要使剩下来的铁丝尽可能长，因此每一条线段总是前面的相邻2段之和），依次为：1、1、2、3、5、8、13、21、34、55，以上各数之和为 143，与 144 相差 1，因此可以取最后一段为 56，这时 n 达到最大为 10。

我们看到，“每段的长度不小于 1”这个条件起了控制全局的作用，正是这个最小数1 产生了斐波那契数列，如果把 1 换成其他数，递推关系保留了，但这个数列消失了。这里，三角形的三边关系定理和斐波那契数列发生了一个联系。

在这个问题中，144>143，这个143是斐波那契数列的前项和，我们是把144超出143的部分加到最后的一个数上去，如果加到其他数上，就有3条线段可以构成三角形了。

影视作品中的斐波那契数列

斐波那契数列在欧美可谓是尽人皆知，于是在电影这种通俗艺术中也时常出现，比如在风靡一时的《达芬奇密码》里它就作为一个重要的符号和情节线索出现，在《魔法玩具城》里又是在店主招聘会计时随口问的问题。可见此数列就像黄金分割一样流行。可是虽说叫得上名，多数人也就背过前几个数，并没有深入理解研究。在电视剧中也出现斐波那契数列，比如：日剧《考试之神》第五回，义嗣做全国模拟考试题中的最后一道数学题~在FOX 热播美剧《Fringe》中更是无数次引用，甚至作为全剧宣传海报的设计元素之一。

斐波那契弧线

斐波那契弧线，也称为斐波那契扇形线。第一，此趋势线以二个端点为准而画出，例如，最低点反向到最高点线上的两个点。然后通过第二点画出一条“无形的（看不见的）”垂直线。然后，从第一个点画出第三条趋势线：38.2%， 50%和61.8%的无形垂直线交叉。

斐波纳契弧线，是潜在的支持点和阻力点水平价格。斐波纳契弧线和斐波纳契扇形线常常在图表里同时绘画出。支持点和阻力点就是由这些线的交汇点得出。

要注意的是弧线的交叉点和价格曲线会根据图表数值范围而改变，因为弧线是圆周的一部分，它的形成总是一样的。

下载 (14.04 KB)

2021-10-15 10:20

质数

斐波那契质数由斐波那契序列中的质数组成，是整数质数序列。

第一组质数序列是：2，3，5，13，89，233，1597，28657，514229，433494437，2971215073……

C#代码实现

1. public static int GetiNum(int i) {
   
2.     long preVal = 1;
   
3.     long prePreVal = 0;
   
4.     if (n < 2)
   
5.         return n;
   
6.     long loop = 1;
   
7.     long returnVal = 0;
   
8.     while (loop < n) {
   
9.         returnVal = preVal + prePreVal;
   
10.         prePreVal = preVal;
    
11.         preVal = returnVal;
    
12.         loop++;
    
13.     }
    
14.     return returnVal;
    
15. }

复制代码

Java代码实现

1. //①==================================
   
2. /**
   
3. * 平推方法实现
   
4. */
   
5. public static long fibLoop(int num) {
   
6.     if(num < 1 || num > 92)
   
7.         return 0;
   
8.     long a = 1;
   
9.     long b = 1;
   
10.     long temp;
    
11.     for(int i = 2; i < num; i++) {
    
12.         temp = a;
    
13.         a = b;
    
14.         b += temp;
    
15.     }
    
16.     return b;
    
17. }
    
18. 
    
19. //②==================================
    
20. /**
    
21. * 递归方法实现
    
22. * f(n) = f(n - 1) + f(n - 2)
    
23. * 最高支持 n = 92 ，否则超出 Long.MAX_VALUE
    
24. * @param num n
    
25. * @return f(n)
    
26. */
    
27. public static long fibRec(int num) {
    
28.     if(num < 1)
    
29.         return 0;
    
30.     if(num < 3)
    
31.         return 1;
    
32.     return fibRec(num - 1) + fibRec(num - 2);
    
33. }
    
34. 
    
35. //③==================================
    
36. static long[] l = new long[93];
    
37. static {
    
38.     l[1] = 1;
    
39. }
    
40. /**
    
41. * 带有缓存的方法，比fibRec方法性能好很多
    
42. */
    
43. public static long fibBuffRec(int num) {
    
44.     if(num < 1 || num > 92)
    
45.         return 0;
    
46.     if(l[num] == 0)
    
47.         l[num] = fibBuffRec(num - 1) + fibBuffRec(num - 2);
    
48.     return l[num];
    
49. }
    
50. 
    
51. //④==================================
    
52. static List<BigDecimal> list = new ArrayList<BigDecimal>(93);
    
53. static {
    
54.     list.add(BigDecimal.ZERO);
    
55.     list.add(BigDecimal.ONE);
    
56. }
    
57. /**
    
58. * 1，2，3，4，5，6， 7 ，8
    
59. * 1，1，2，3，5，8，13，21
    
60. * 支持num超过92的超大型数字，使用了ArrayList进行缓存以提高性能
    
61. */
    
62. public static BigDecimal fibBig(int num) {
    
63.     if(num < 0)
    
64.         return list.get(0);
    
65.     if (list.size() <= num)
    
66.         list.add(fibBig(num - 1).add(fibBig(num - 2)));
    
67.     return list.get(num);
    
68. }

复制代码

Javascript代码实现

1. //循环算法
   
2. function f(n){
   
3.   if(n == 0){
   
4.     return 0;
   
5.   }else if(n ==1){
   
6.   return 1;
   
7.   }else{
   
8.     var fn1 = 0;
   
9.     var fn2 = 1;
   
10.     var fnx = 0;
    
11.     for(var i=0;i<n-1; i++){
    
12.       var newfn1 = fn2;
    
13.       fnx = fn1 + fn2;
    
14.       fn1 = fn2;
    
15.       fn2 = fnx;
    
16.   }
    
17.     return fnx;
    
18.   }
    
19. }
    
20. //===============================
    
21. //递归算法
    
22. function fib(count) {
    
23. //参数判断
    
24.     var count = parseInt(count);
    
25.      if (isNaN(count) || count <= 0) {
    
26.          return 0;
    
27.     }
    
28.     function f(count) {
    
29.         if (count <= 2) {
    
30.             return 1;
    
31.          }
    
32.          return f(count - 1) + f(count - 2);
    
33.      }
    
34.         return f(count);
    
35. }

复制代码

C++代码实现

基本循环算法

1. #include<bits/stdc++.h>
   
2. using namespace std;
   
3. int main()
   
4. {
   
5.     int a=0,b=0,c=1,n;
   
6.     cin>>n;//输入n
   
7.     for(int i=1;i<=n-1;i++)
   
8.     {
   
9.         a=b;
   
10.         b=c;
    
11.         c=a+b;
    
12.     }
    
13.     cout<<c;//输出最终结果
    
14.     return 0;
    
15. }

复制代码

数组算法实现

1. #include<iostream>
   
2. using namespace std;
   
3. int main()
   
4. {
   
5.     int a[30],i,n;
   
6.     cin>>n;
   
7.     a[1]=a[0]=1;
   
8.     for(i=2;i<n;i++)
   
9.     {
   
10.         a[i]=a[i-2]+a[i-1];
    
11.     }
    
12.     cout<<a[n-1];
    
13.     return 0;
    
14. }

复制代码

递归算法实现

1. #include<iostream>
   
2. using namespace std;
   
3. int f(int n)
   
4. {
   
5.     return (n<3)? 1 : f(n-1)+f(n-2);//如果是前两项，则输出1
   
6. }
   
7. int main()
   
8. {
   
9.     int n;
   
10.     cin>>n;
    
11.     cout<<f(n);
    
12.     return 0;
    
13. }

复制代码

递归算法优化

1. # include <bits/stdc++.h>
   
2. const int MAX=101;
   
3. using namespace std;
   
4. int a[MAX];
   
5. int f(int n)
   
6. {
   
7.     if(a[n]!=-1) return a[n];
   
8.     else
   
9. {
   
10.         a[n]=f(n-1)+f(n-2);
    
11.         return a[n];
    
12.     }
    
13. }
    
14. int main()
    
15. {
    
16.     int n;
    
17.     cin>>n;
    
18.     for(int i=0;i<=MAX-1;i++)
    
19.     {//初始化
    
20.         a[i]=-1;
    
21.     }
    
22.     a[0]=0;a[1]=1;
    
23.     cout<<f(n);
    
24.     return 0;
    
25. }

复制代码

高精度计算

1. #include <bits/stdc++.h>
   
2. using namespace std;
   
3. char sum[1200];
   
4. int s=0,m=0,n;
   
5. int main()
   
6. {
   
7.     cin>>n;
   
8.     string s1,s2;
   
9.     int a[1200],b[1200];
   
10.     int he,i;
    
11.     s1="0";
    
12.     s2="1";
    
13.     for(m=2;m<n+1;m++)
    
14.     {
    
15.         memset(a,0,sizeof a);
    
16.         memset(b,0,sizeof b);
    
17.         a[0]=s1.length();
    
18.         for(i=1;i<=a[0];i++)
    
19.         {
    
20.             a[i]=s1[a[0]-i]-'0';
    
21.         }
    
22.         b[0]=s2.length();
    
23.         for(i=1;i<=b[0];i++)
    
24.         {
    
25.             b[i]=s2[b[0]-i]-'0';
    
26.         }
    
27.         he=(a[0]>b[0]?a[0]:b[0]);
    
28.         for(i=1;i<=he;i++)
    
29.         {
    
30.             a[i]+=b[i];
    
31.             a[i+1]+=a[i]/10;
    
32.             a[i]%=10;
    
33.         }
    
34.         he++;
    
35.         while((a[he]==0)&&(he>1))
    
36.         he--;
    
37.             for(i=he,s=0;i>=1;i--,s++)
    
38.             {
    
39.                 sum[s]=a[i]+'0';
    
40.             }
    
41.         s1=s2;
    
42.         s2=sum;
    
43.     }
    
44.     cout<<s2<<endl;
    
45.     return 0;
    
46. }

复制代码

Python3代码实现

#输出在3000以内的斐波那契数列

一、从最大值考虑

1. numMax = int(input('please input  a maxnumber : '))
   
2. 
   
3. 
   
4. def flibsOne(numMax):   
   
5.      
   
6.     c = []   
   
7.      
   
8.     a, b = 0, 1   
   
9.      
   
10.     while a < numMax:
    
11.          
    
12.         a, b = b, a + b        
    
13.          
    
14.         c.append(a)   
    
15.      
    
16.     c.remove(c[-1])   
    
17.      
    
18.     print(c)

复制代码

二、从位数考虑

1. num = int(input('please input  a number : '))
   
2. 
   
3. def flibsTwo(num):   
   
4.      
   
5.     list1 = []   
   
6.      
   
7.     for i in range(num):        
   
8.             if i <=1:
   
9.                 list1.append(1)
   
10.             else:   
    
11.                 list1.append(list1[-2] + list1[-1])
    
12.     return list1   
    
13. 
    
14. print(flibsTwo(num)) #输出num位数列

复制代码

第三种，根据f（n）= f(n-1)+f(n-2)实现

1. Fbs = [1,1]#斐波那契数列前两位
   
2. n = 3
   
3. s = input("Maxmun ")#输入最大次数
   
4. while n != (int(s)+1) :#因为差一原则所以要再加一
   
5.     a = Fbs[-1]
   
6.     b = Fbs[-2]
   
7.     fb = a+b
   
8.     print(str(n)+" "+str(fb))
   
9.     n = n +1
   
10.     Fbs.append(fb)

复制代码

php代码实现

1.   $n = 输入值;
   
2.     if ($n >= 3) {
   
3.         $x = 1;$y = 1;$n = $n - 2;
   
4.         do {
   
5.             $fs   = $x + $y;
   
6.             $x    = $y;
   
7.             $y    = $fs;
   
8.             echo $fs.',';
   
9.             $n--;
   
10.         } while ($n > 0);
    
11. }

复制代码

Rust代码实现

1. // Rust代码实现
   
2. 
   
3. fn main() {
   
4.   println!("{} {} {} {} {}", fib(0), fib(1), fib(2), fib(3), fib(4));
   
5. }
   
6. 
   
7. fn fib(d: i32) -> i32 {
   
8.   if d == 0 || d == 1 {
   
9.     d
   
10.   } else {
    
11.     ficc(d - 2) + ficc(d - 1)
    
12.   }
    
13. }

复制代码

论坛上面相关的贴子：

[MC源码] ZigZag Fibonacci Plus 指标【主图指标】：http://www.qhlt.cn/thread-67029-1-1.html

[TS源码] The V-Trade, Part 3:Fibonacci Projections And Daily Pivots源码：http://www.qhlt.cn/thread-23563-1-1.html

[TS源码] 欧美期货量化策略推荐系列之trading system for FUTURES that uses the Fibonacci number "13：http://www.qhlt.cn/thread-62186-1-1.html

斐波那契（Leonardo Pisano ,Fibonacci, Leonardo Bigollo，1175年-1250年）：http://www.qhlt.cn/thread-115501-1-1.html