Java 在数组中存储斐波那契并打印用户所需的值

我已经编写了一个用于打印斐波那契级数的代码，我想将它存储在一个动态数组中。 然后，当用户输入一个值以打印数组的特定元素时，它应该显示存储在数组中的所需斐波那契数的值

package fibonacci;

import java.util.Scanner;

public class Fibonacci {
    public static void main(String[] args){
        int size=new Scanner(System.in).nextInt();
        int fibonacci[]=new int[size];
        int i=3;

        System.out.println("The number");

        int number=new Scanner(System.in).nextInt();
        for(int i1=1;i1<=number;i1++){

            System.out.println(fibonacci(i1)+" ");

        }
        int j=new Scanner(System.in).nextInt();
        System.out.println(fibonacci[i]);

    }




        public static int fibonacci(int number){
                if(number==1||number==2){
                        return 1;

                    }
                    return fibonacci(number-1)+fibonacci(number-2);

            }
    }

package-fibonacci；
导入java.util.Scanner；
公共类斐波那契{
公共静态void main（字符串[]args）{
int size=新扫描仪（System.in）.nextInt（）；
int fibonacci[]=新的int[size]；
int i=3；
System.out.println（“编号”）；
int number=新扫描仪（System.in）.nextInt（）；
对于（int i1=1；i1，只有大约94个fibonacci值适合
long
，因此您可以在启动时创建这些值。使用循环创建数字也是
O（n）
，但是使用递归等于指数答案。你很快就能得到比宇宙年龄更长的数字进行计算。
你可以利用数组，像这样使用它

fibonacci[i]=fibonacci[i-1]+fibonnaci[i-2]这将极大地改善代码的执行，因为递归函数可能具有很高的复杂性，您不会注意到小值之间的差异，但对于像fibonacci[1000]这样的大值你会注意到，你会让你的cpu和内存受损，让它们屈服，所以我会给你Fibonacci1这是你的版本，Fibonacci2是更简单的版本：

Fibonacci1

  import java.util.Scanner;

    public class Fibonacci1 {
        public static void main(String[] args) {
            System.out
                    .println("enter the upper bound of the serie(Size of the array of fibonacci serie):");
            Scanner scanner = new Scanner(System.in);
            int size = scanner.nextInt();
            int fibonacci[] = new int[size];

            for (int i = 0; i < size; i++) {
                fibonacci[i] = fibonacci(i+1);
            }

            System.out.println("enter a number between 1 and " + size);

            int j = scanner.nextInt();
            while (j < 0 || j > size) {
                if (j < 0) {
                    System.out.println("j<0");
                }
                if (j > size) {
                    System.out.println("j>" + size);
                }
                System.out.println("please enter a number between 1 and " + size);
            }

            System.out.println("Fibonacci[" + j + "]=" + fibonacci[j - 1]);
            scanner.close();
        }

        public static int fibonacci(int number) {
            if (number == 1 || number == 2) {
                return 1;
            }
            return fibonacci(number - 1) + fibonacci(number - 2);

        }
    }

import java.util.Scanner；
公共类Fibonacci1{
公共静态void main（字符串[]args）{
系统输出
.println（“输入序列的上限（斐波那契序列数组的大小）：”；
扫描仪=新的扫描仪（System.in）；
int size=scanner.nextInt（）；
int fibonacci[]=新的int[size]；
对于（int i=0；i大小）{
if（j<0）{
系统输出打印项次（“j”+尺寸）；
}
System.out.println（“请输入一个介于1和“+大小”之间的数字）；
}
System.out.println（“Fibonacci[“+j+”]=“+Fibonacci[j-1]）；
scanner.close（）；
}
公共静态整数fibonacci（整数）{
如果（数字==1 | |数字==2）{
返回1；
}
返回fibonacci（数字-1）+fibonacci（数字-2）；
}
}

Fibonacci2:

包装堆垛溢出

import java.util.Scanner;

public class Fibonnaci {
    public static void main(String[] args) {
        System.out
                .println("enter the upper bound of the serie(Size of the array of fibonacci serie):");
        Scanner scanner = new Scanner(System.in);
        int size = scanner.nextInt();
        int fibonacci[] = new int[size];

        for (int i = 0; i < size; i++) {
            fibonacci[i] = fibonacci(i + 1, fibonacci);
        }

        System.out.println("enter a number between 1 and " + size);

        int j = scanner.nextInt();
        while (j < 0 || j > size) {
            if (j < 0) {
                System.out.println("j<0");
            }
            if (j > size) {
                System.out.println("j>" + size);
            }
            System.out.println("please enter a number between 1 and " + size);
        }
        System.out.println("Fibonacci[" + j + "]=" + fibonacci[j - 1]);
        scanner.close();
    }

    /*
     * changed the fibonacci function in order to use the already calculated
     * fibonacci elements
     * fibSerie[n]=fibonnaci[n-1]
     * fibSerie[n-1]=fibonnaci[n-2];
     * fibSerie[n-2]=fibonnaci[n-3];
     * because arrays start from 0 so fibSerie[1]=fibonnaci[0];
     */
    public static int fibonacci(int number, int[] fibonacci) {
        if (number == 1 || number == 2) {
            return 1;
        }
        return fibonacci[number - 2] + fibonacci[number - 3];

    }
}

import java.util.Scanner；
公共级Fibonnaci{
公共静态void main（字符串[]args）{
系统输出
.println（“输入序列的上限（斐波那契序列数组的大小）：”；
扫描仪=新的扫描仪（System.in）；
int size=scanner.nextInt（）；
int fibonacci[]=新的int[size]；
对于（int i=0；i大小）{
if（j<0）{
系统输出打印项次（“j”+尺寸）；
}
System.out.println（“请输入一个介于1和“+大小”之间的数字）；
}
System.out.println（“Fibonacci[“+j+”]=“+Fibonacci[j-1]）；
scanner.close（）；
}
/*
*更改斐波那契函数以使用已计算的
*斐波那契元
*fibSerie[n]=fibonnaci[n-1]
*fibSerie[n-1]=fibonnaci[n-2]；
*fibSerie[n-2]=fibonnaci[n-3]；
*因为数组从0开始，所以fibSerie[1]=fibonnaci[0]；
*/
公共静态int-fibonacci（int-number，int[]fibonacci）{
如果（数字==1 | |数字==2）{
返回1；
}
返回fibonacci[number-2]+fibonacci[number-3]；
}
}
那么，实际的问题是什么？-先生，我在网上看到的问题是使用递归解决的itself@ManojKSharmaJava没有像其他一些语言那样优化递归，例如，它没有记忆，所以你必须使用迭代（正如公认的答案那样）虽然使用一个简单的循环会更干净。是的，我同意。但是我收到的问题是这样的。谢谢你能解释为什么在fibonacci1中你给出了fibonacci（i）=fibonacci（i+1）？这主要是因为数组从0开始索引，所以在fibonacciArray[0]中我们存储fibonacciArray（1）。所以通常fibonacciArray[n-1]会存储fibonacciArray（1）（n） 我不完全理解你的观点。但我会再看一遍。谢谢好的，让我们将用于保存斐波那契结果的数组重命名为int[]斐波那契数组okeyok让我们将用于保存斐波那契结果的数组重命名为int[]fibonacci（n）是fibonacci序列的第n个元素，当我们开始保存fibonacci函数给出的结果时，我们将fibonacci（1）存储在fibonacci数组[0]中，fibonacci（2）存储在fibonacci数组[1]中，所以你会注意到fibonacci数组[n]中有间隙将存储斐波那契（n+1）的结果