斐波那契数列c语言JAVA,斐波那契数列的神奇

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

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

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

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

多了的一在哪？

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

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

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

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

C语言程序

//利用循环输出前40项

#include

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

#include

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}else{

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

}

}

}

public int getPos(){

return pos;

}

public byte getBase(int index){

return base[index];

}

}