斐波那契数列的神奇

近期编写斐波那契数列程序，在网上无意间发现了这些，与校友们分享一下！！！！

　斐波那契数列中的斐波那契数会经常出现在我们的眼前——比如松果、凤梨、树叶的排列、某些花朵的花瓣数、黄金矩形、黄金分割、等角螺线等，有时也可能是我们对斐波那契额数过于热衷，把原来只是巧合的东西强行划分为斐波那契数。比如钢琴上白键的8，黑键上的5都是斐波那契数，应该把它看做巧合还是规律呢？

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

　　从第二项开始，每个奇数项的平方都比前后两项之积多1，每个偶数项的平方都比前后两项之积少1。（注：奇数项和偶数项是指项数的奇偶，而并不是指数列的数字本身的奇偶，比如第四项3是奇数，但它是偶数项，第五项5是奇数，它是奇数项，如果认为数字3和5都是奇数项，那就误解题意，怎么都说不通）

　　

多了的一在哪？

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

　　某人把一个8*8的方格切成四块，拼成一个5*13的长方形，故

　　作惊讶地问你：为什么64=65？其实就是利用了斐波那契数列的这个性质：5、8、13正是数列中相邻的三项，事实上前后两块的面积

　　确实差1，只不过后面那个图中有一条细长的狭缝，一般人不容易注意到。

C语言程序

　　//利用循环输出前40项

　　#include <stdio.h>

　　int main()

　　{

　　long fib[41] = {0,1};

　　int i;

　　for(i=2;i<41;i++)fib[i] = fib[i-1]+fib[i-2];

　　for(i=1;i<41;i++)printf("F%d==%d\n",i,fib[i]);

　　getch();

　　return 0;

　　}

　　//利用 递归 实现指定项输出

　　第n项和。

　　long fib(int n)

　　{

　　if (n==0) return 0;

　　if (n==1) return 1;

　　if (n>1) return fib(n-1)+fib(n-2);

　　}

　　int main()

　　{

　　int k=1;

　　while(k!=0)

　　{

　　puts("input a num n 0 for exit");

　　scanf("%d",&k);

　　printf("%ld\n",fib(k));

　　}

　　getch();

　　return 0;

　　}

　　//高精度斐波那契数列（3000长度的可求到第10000多项）

　　#include<stdio.h>

　　#include<iostream>

　　using namespace std;

　　int a[3001]={};

　　int b[3001]={};

　　int c[3001]={};

　　int n;

　　int main()

　　{

　　scanf("%d",&n);

　　if(n<3)

　　{printf("%d\n",n);

　　return 0;}

　　c[1]=2;

　　b[1]=1;

　　for(int i=1;i<=n-2;i++)

　　{for(int j=1;j<=3000;j++)

　　{a[j]=b[j];

　　b[j]=c[j];

　　c[j]=0;}

　　for(int j=1;j<=3000;j++)

　　{c[j]=c[j]+a[j]+b[j];

　　if(c[j]>=10)

　　{c[j]=c[j]-10;

　　c[j+1]=1;}

　　}

　　}

　　int i=3000;

　　while(c[i]==0) i--;

　　for(i=i;i>=1;i--)

　　printf("%d",c[i]);

　　printf("\n");

　　system("pause");

　　return 0;

　　}

C#语言程序

　　public class Fibonacci

　　{

　　//NormRen

　　static void Main(string[] args)

　　{

　　int x = 0, y = 1;

　　for (int j = 1; j < 10; j++, y = x + y, x = y - x)

　　Console.Write(y + " ");

　　}

　　}

Java语言程序

　　/*

　　快速计算第n个Java程序，一秒计算第10万个数字。

　　Intel Core2 Duo CPU P8600 2.4GHz 计算第100000个斐波那契数列的数所花时间（毫秒）：

　　第100000：967.8 981.1 988.8 966.3 994.4

　　*/

　　public class Fib {

　　//n为第n个斐波那契数列的数

　　public static BigInteger compute2(int n) {

　　if (n == 1 || n == 2) {

　　return BigInteger.ONE;

　　}

　　BigInteger num1 = BigInteger.ONE;

　　BigInteger num2 = BigInteger.ONE;

　　BigInteger result = BigInteger.ZERO;

　　for (int i = 2; i < n; i++) {

　　result = num1 .add(num2);

　　num2 = num1;

　　num1 = result;

　　}

　　return result;

　　}

　　}

　　public class Fibonacci

　　{

　　public static void main(String[] args)

　　{

　　int x=1,y=1;

　　System.out.println(x+" ");

　　for(int i=1;i<=20;i++)

　　{

　　System.out.println(y+" ");

　　y=x+y;x=y-x;

　　}

　　}

　　}

　　Java语言程序(高精度，约一秒钟计算第20000个数值)　

　　import java.util.Scanner;

　　public class Main{

　　public static void main(String[] args){

　　Scanner s=new Scanner(标准输入);

　　int n=s.nextInt();

　　do{

　　cul(n);

　　n=s.nextInt();

　　}while(n>0);//当n<=0时终止

　　}

　　private static void cul(int n) {

　　BigIntT b=new BigIntT();

　　BigIntT a=new BigIntT();

　　b.formatBigInt("1");

　　a.formatBigInt("2");

　　if(n==1 || n==2) {

　　System.out.println(1);

　　return;

　　}

　　int i=3;

　　for(;i<=n;i++){

　　if(i%2>0)

　　b.add(a);

　　else

　　a.add(b);

　　}

　　BigIntT t=null;

　　if(i%2>0) t=b;

　　else t=a;

　　for(int j=t.getPos();j<100000;j++)

　　System.out.print(t.getBase(j));

　　System.out.println();

　　}

　　}

　　class BigIntT{

　　int max=100000;

　　private byte[] base=new byte[max];

　　private int pos=max;

　　public void formatBigInt(String arr){

　　int l=arr.length();

　　if(l==0) return;

　　int tmp=l-1;

　　for(int i=max-1;i>=max-l;i--){

　　base[i]=(byte) (arr.charAt(tmp--)-'0');

　　pos--;

　　}

　　}

　　public void add(BigIntT right) {

　　int bigger=this.getPos()>right.getPos()?right.getPos():this.getPos();

　　pos=bigger;

　　for(int i=max-1;i>=pos-2;i--){

　　int t=this.base[i]+right.getBase(i);

　　if(t>=10){

　　this.base[i]=(byte) (t%10);

　　this.base[i-1]+=t/10;

　　if(i-1<pos) pos=i-1;

　　}else{

　　this.base[i]=(byte) t;

　　}

　　}

　　}

　　public int getPos(){

　　return pos;

　　}

　　public byte getBase(int index){

　　return base[index];

　　}

　　}