ThinkinJava之斐波那契数列

斐波纳契数列（Fibonacci Sequence），又称黄金分割数列。

成都创新互联公司专注于宁化企业网站建设,成都响应式网站建设公司,商城网站制作。宁化网站建设公司,为宁化等地区提供建站服务。全流程定制网站，专业设计，全程项目跟踪，成都创新互联公司专业和态度为您提供的服务

指的是这样一个数列：1、1、2、3、5、8、13、21、……这个数列从第三项开始，每一项都等于前两项之和。

在数学上，斐波纳契数列以如下被以递归的方法定义：F0=0，F1=1，Fn=F(n-1)+F(n-2)（n>=2，n∈N*）在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用。

斐波那契数列的***，是意大利数学家列昂纳多·斐波那契（Leonardo Fibonacci）。

与黄金分割的关系

有趣的是：这样一个完全是自然数的数列，通项公式却是用无理数来表达的。而且当n趋向于无穷大时，后一项与前一项的比值的小数部分越来越逼近黄金分割0.618.　　 1÷1=1，2÷1=2，3÷2=1.5，5÷3=1.666...，8÷5=1.6，…………，89÷55=1.6181818…，…………233÷144=1.618055…75025÷46368=1.6180339889…... 　　

越到后面，这些比值越接近黄金比。

证明：

a[n+2]=a[n+1]+a[n]。

两边同时除以a[n+1]得到：

a[n+2]/a[n+1]=1+a[n]/a[n+1]。

若a[n+1]/a[n]的极限存在，设其极限为x，

则lim[n->；∞](a[n+2]/a[n+1])=lim[n->；∞](a[n+1]/a[n])=x。

所以x=1+1/x。

即x²=x+1。

所以极限是黄金分割比..

如果你看到有这样一个题目：

某人把一个8*8的方格切成四块，拼成一个5*13的长方形，故作惊讶地问你：为什么64=65？

其实就是利用了斐波那契数列的这个性质：5、8、13正是数列中相邻的三项，事实上前后两块的面积确实差1，只不过后面那个图中有一条细长的狭缝，一般人不容易注意到。

在杨辉三角中隐藏着斐波那契数列

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

每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…

斐波那契数列中是否存在无穷多个素数？[维基百科]

在斐波那契数列中，有素数：

2,3,5,13,89,233,1597,28657,514229,433494437,2971215073,99194853094755497,1066340417491710595814572169,19134702400093278081449423917……

目前已知***素数是第81839个斐波那契数，一共有17103位数。

相关的数学问题

1.排列组合

有一段楼梯有10级台阶，规定每一步只能跨一级或两级，要登上第10级台阶有几种不同的走法? 　　

这就是一个斐波那契数列：

登上***级台阶有一种登法；登上两级台阶，有两种登法；登上三级台阶，有三种登法；登上四级台阶，有五种登法……　　

1，2，3，5，8，13……所以，登上十级，有89种走法。　　

类似的，一枚均匀的硬币掷10次，问不连续出现正面的可能情形有多少种？　　

答案是（1/√5)*{[(1+√5)/2]^（10+2） - [(1-√5)/2]^（10+2）}=144种。

2.数列中相邻两项的前项比后项的极限

当n趋于无穷大时，F(n)/F(n+1）的极限是多少？　　

这个可由它的通项公式直接得到，极限是（-1+√5)/2，这个就是黄金分割的数值，也是代表大自然的和谐的一个数字。　　

3.求递推数列a(1)=1，a(n+1)=1+1/a(n）的通项公式

由数学归纳法可以得到：a(n)=F(n+1)/F(n），将斐波那契数列的通项式代入，化简就得结果。

4.兔子繁殖问题（关于斐波那契数列的别名）

斐波那契数列又因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”。　　

一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔都不死，那么一年以后可以繁殖多少对兔子？ 　　

我们不妨拿新出生的一对小兔子分析一下：　　

***个月小兔子没有繁殖能力，所以还是一对　　

两个月后，生下一对小兔民数共有两对　　

三个月以后，老兔子又生下一对，因为小兔子还没有繁殖能力，所以一共是三对

　　－－－－－－ 　　依次类推可以列出下表：

经过月数

0

1

2

3

4

5

6

7

8

9

10

11

12

幼仔对数

1

0

1

1

2

3

5

8

13

21

34

55

89

成兔对数

0

1

1

2

3

5

8

13

21

34

55

89

144

总体对数

1

1

2

3

5

8

13

21

34

55

89

144

233

幼仔对数=前月成兔对数　　

成兔对数=前月成兔对数+前月幼仔对数　　

总体对数=本月成兔对数+本月幼仔对数　　

可以看出幼仔对数、成兔对数、总体对数都构成了一个数列。这个数列有关十分明显的特点，那是：前面相邻两项之和，构成了后一项。　　

这个数列是意大利中世纪数学家斐波那契在<；算盘全书>；中提出的，这个级数的通项公式，除了具有a(n+2)=an+a(n+1）的性质外，还可以证明通项公式为：an=（1/√5）*{[(1+√5)/2]^n-[(1-√5)/2]^n}（n=1,2,3.....）　　`````

可惜本人是文科生，看不懂也不记得那些所谓的数学公式了，以前素材只摘选感兴趣的部分。

来源于百度：http://baike.baidu.com/view/816.htm

我只感兴趣的是后面这几段代码的实现：

 
 
 
 
    
  
  
  
  
  1. package com.tudou.t1;  
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.math.BigInteger;  
    4.   
  
  
  
  4. import java.util.Scanner;  
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6. /**  
    7.   
  
  
  
  7.  * 斐波那契数列 1,2,3,5,8,13,21....[]  
    8.   
  
  
  
  8.  *   
    9.   
  
  
  
  9.  * @author lz  
    10.   
  
  
  
  10.  *   
    11.   
  
  
  
  11.  */ 
    12.   
  
  
  
  12. public class Fibonacci {  
    13.   
  
  
  
  13.     public static void main(String[] args) {  
    14.   
  
  
  
  14.         fib();//常规算法  
    15.   
  
  
  
  15.         System.out.println(compute2(5));//计算第n个斐波那契数列的数  
    16.   
  
  
  
  16.         fibHign();// Java语言程序（高精度，约一秒钟计算第20000个数值）  
    17.   
  
  
  
  17.     }  
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.     private static void fib() {  
    20.   
  
  
  
  20.         int x = 1, y = 1;  
    21.   
  
  
  
  21.         System.out.println(x);  
    22.   
  
  
  
  22.         for (int i = 1; i <= 5; i++) {  
    23.   
  
  
  
  23.             System.out.println(y);  
    24.   
  
  
  
  24.             y = x + y;  
    25.   
  
  
  
  25.             x = y - x;  
    26.   
  
  
  
  26.         }  
    27.   
  
  
  
  27.     }  
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29.     // n为第n个斐波那契数列的数  
    30.   
  
  
  
  30.     public static BigInteger compute2(int n) {  
    31.   
  
  
  
  31.         if (n == 1 || n == 2) {  
    32.   
  
  
  
  32.             return BigInteger.ONE;  
    33.   
  
  
  
  33.         }  
    34.   
  
  
  
  34.         BigInteger num1 = BigInteger.ONE;  
    35.   
  
  
  
  35.         BigInteger num2 = BigInteger.ONE;  
    36.   
  
  
  
  36.         BigInteger result = BigInteger.ZERO;  
    37.   
  
  
  
  37.         for (int i = 2; i < n; i++) {  
    38.   
  
  
  
  38.             result = num1.add(num2);  
    39.   
  
  
  
  39.             num2 = num1;  
    40.   
  
  
  
  40.             num1 = result;  
    41.   
  
  
  
  41.         }  
    42.   
  
  
  
  42.         return result;  
    43.   
  
  
  
  43.     }  
    44.   
  
  
  
  44.  
    45.   
  
  
  
  45.     // Java语言程序（高精度，约一秒钟计算第20000个数值）  
    46.   
  
  
  
  46.     private static void fibHign() {  
    47.   
  
  
  
  47.         Scanner s = new Scanner(System.in);  
    48.   
  
  
  
  48.         System.out.print("请输入一个整数:");  
    49.   
  
  
  
  49.         int n = s.nextInt();  
    50.   
  
  
  
  50.         do {  
    51.   
  
  
  
  51.             cul(n);  
    52.   
  
  
  
  52.             n = s.nextInt();  
    53.   
  
  
  
  53.         } while (n > 0);// 当n<=0时终止  
    54.   
  
  
  
  54.     }  
    55.   
  
  
  
  55.  
    56.   
  
  
  
  56.     private static void cul(int n) {  
    57.   
  
  
  
  57.         BigIntT b = new BigIntT();  
    58.   
  
  
  
  58.         BigIntT a = new BigIntT();  
    59.   
  
  
  
  59.         b.formatBigInt("1");  
    60.   
  
  
  
  60.         a.formatBigInt("2");  
    61.   
  
  
  
  61.         if (n == 1 || n == 2) {  
    62.   
  
  
  
  62.             System.out.println(1);  
    63.   
  
  
  
  63.             return;  
    64.   
  
  
  
  64.         }  
    65.   
  
  
  
  65.         int i = 3;  
    66.   
  
  
  
  66.         for (; i <= n; i++) {  
    67.   
  
  
  
  67.             if (i % 2 > 0)  
    68.   
  
  
  
  68.                 b.add(a);  
    69.   
  
  
  
  69.             else 
    70.   
  
  
  
  70.                 a.add(b);  
    71.   
  
  
  
  71.         }  
    72.   
  
  
  
  72.         BigIntT t = null;  
    73.   
  
  
  
  73.         if (i % 2 > 0)  
    74.   
  
  
  
  74.             t = b;  
    75.   
  
  
  
  75.         else 
    76.   
  
  
  
  76.             t = a;  
    77.   
  
  
  
  77.         for (int j = t.getPos(); j < 100000; j++)  
    78.   
  
  
  
  78.             System.out.print(t.getBase(j));  
    79.   
  
  
  
  79.         System.out.println();  
    80.   
  
  
  
  80.     }  
    81.   
  
  
  
  81. }  
    82.   
  
  
  
  82.  
    83.   
  
  
  
  83. class BigIntT {  
    84.   
  
  
  
  84.     int max = 100000;  
    85.   
  
  
  
  85.     private byte[] base = new byte[max];  
    86.   
  
  
  
  86.     private int pos = max;  
    87.   
  
  
  
  87.  
    88.   
  
  
  
  88.     public void formatBigInt(String arr) {  
    89.   
  
  
  
  89.         int l = arr.length();  
    90.   
  
  
  
  90.         if (l == 0)  
    91.   
  
  
  
  91.             return;  
    92.   
  
  
  
  92.         int tmp = l - 1;  
    93.   
  
  
  
  93.         for (int i = max - 1; i >= max - l; i--) {  
    94.   
  
  
  
  94.             base[i] = (byte) (arr.charAt(tmp--) - '0');  
    95.   
  
  
  
  95.             pos--;  
    96.   
  
  
  
  96.         }  
    97.   
  
  
  
  97.     }  
    98.   
  
  
  
  98.  
    99.   
  
  
  
  99.     public void add(BigIntT right) {  
    100.   
  
  
  
  100.         int bigger = this.getPos() > right.getPos() ? right.getPos() : this 
    101.   
  
  
  
  101.                 .getPos();  
    102.   
  
  
  
  102.         pos = bigger;  
    103.   
  
  
  
  103.         for (int i = max - 1; i >= pos - 2; i--) {  
    104.   
  
  
  
  104.             int t = this.base[i] + right.getBase(i);  
    105.   
  
  
  
  105.             if (t >= 10) {  
    106.   
  
  
  
  106.                 this.base[i] = (byte) (t % 10);  
    107.   
  
  
  
  107.                 this.base[i - 1] += t / 10;  
    108.   
  
  
  
  108.                 if (i - 1 < pos)  
    109.   
  
  
  
  109.                     pos = i - 1;  
    110.   
  
  
  
  110.             } else {  
    111.   
  
  
  
  111.                 this.base[i] = (byte) t;  
    112.   
  
  
  
  112.             }  
    113.   
  
  
  
  113.         }  
    114.   
  
  
  
  114.     }  
    115.   
  
  
  
  115.  
    116.   
  
  
  
  116.     public int getPos() {  
    117.   
  
  
  
  117.         return pos;  
    118.   
  
  
  
  118.     }  
    119.   
  
  
  
  119.  
    120.   
  
  
  
  120.     public byte getBase(int index) {  
    121.   
  
  
  
  121.         return base[index];  
    122.   
  
  
  
  122.     }  
    123.   
  
  
  
  123. }  
    124.

控制台输出结果为：

1 
1 
2 
3 
5 
8 
5

请输入一个整数:500

139423224561697880139724382870407283950070256587697307264108962948325571622863290

691557658876222521294125

感兴趣的朋友，可以玩一下。偶尔玩玩这些也很过瘾呢。

原文链接：http://blog.csdn.net/yaerfeng/article/details/7279210

当前标题：ThinkinJava之斐波那契数列
文章出自：http://www.shufengxianlan.com/qtweb/news13/99763.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

手机网站建设知识

分类信息网

微信小程序　　 　成都网站建设哪家好　　 　鼎尚理发店　　 　成都定制网页设计　　 　主动防护网　　 　九针服饰　　 　四川中建建业　　 　美美搬家　　 　免费收录网站　　 　鸿艺文化　　 　创新互联重庆　　 　绵阳主机托管　　 　深圳惠宜防蚊纱窗　　 　香港空间　　 　轻质隔墙板　　 　眉山做网站　　 　四川审计公司　　 　成都网站建设　　 　成都网站设计　　 　梅州网站建设