LabEx
登录免费加入

如何在 Java 中检查一个数字是否为斐波那契数

JavaBeginner
立即练习

介绍

在这个实验中，你将学习如何用 Java 检查一个给定的数字是否为斐波那契数。我们将探索三种不同的方法来实现这一目标。

首先，你将学习如何生成指定项数的斐波那契数列。然后，你将实现一个方法来检查给定的数字是否存在于生成的数列中。最后，我们将利用一个数学公式来优化检查过程，该公式可以在不生成整个数列的情况下高效地确定一个数字是否为斐波那契数。

生成斐波那契数列

在这一步中，我们将编写一个 Java 程序来生成指定项数的斐波那契数列。斐波那契数列是一个数字序列，其中每个数字都是前两个数字之和，通常从 0 和 1 开始。该序列如下所示：0, 1, 1, 2, 3, 5, 8, 13, 21，依此类推。

我们将创建一个新的 Java 文件并编写代码来生成这个序列。

  1. 如果 WebIDE 尚未打开，请打开它。默认情况下，你应该位于 ~/project 目录中。如果不是，请打开底部的终端并输入：

    cd ~/project

  2. 在 ~/project 目录中创建一个名为 Fibonacci.java 的新文件。你可以通过在左侧的文件资源管理器中右键单击并选择“新建文件”，然后输入 Fibonacci.java 来完成此操作。

  3. 在编辑器中打开 Fibonacci.java 文件，并复制粘贴以下 Java 代码：

    import java.util.Scanner;

public class Fibonacci {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the number of terms for Fibonacci sequence: ");
        int n = scanner.nextInt();

        if (n <= 0) {
            System.out.println("Please enter a positive integer.");
        } else if (n == 1) {
            System.out.println("Fibonacci sequence up to 1 term:");
            System.out.println("0");
        } else {
            System.out.println("Fibonacci sequence up to " + n + " terms:");

            int firstTerm = 0;
            int secondTerm = 1;

            System.out.print(firstTerm + ", " + secondTerm);

            for (int i = 3; i <= n; ++i) {
                int nextTerm = firstTerm + secondTerm;
                System.out.print(", " + nextTerm);
                firstTerm = secondTerm;
                secondTerm = nextTerm;
            }
            System.out.println(); // Print a newline at the end
        }

        scanner.close();
    }
}

    让我们快速了解一下这段代码的关键部分：

    • import java.util.Scanner;：导入 Scanner 类以读取用户输入。
    • public class Fibonacci：声明名为 Fibonacci 的主类。
    • public static void main(String[] args)：程序执行开始的主方法。
    • Scanner scanner = new Scanner(System.in);：创建一个 Scanner 对象以从控制台读取输入。
    • System.out.print("Enter the number of terms... ");：提示用户输入项数。
    • int n = scanner.nextInt();：读取用户输入的整数并将其存储在变量 n 中。
    • if-else if-else 块处理项数 (n) 的不同情况。
    • int firstTerm = 0; int secondTerm = 1;：初始化序列的前两项。
    • System.out.print(firstTerm + ", " + secondTerm);：打印前两项。
    • for 循环计算并打印后续项。
    • int nextTerm = firstTerm + secondTerm;：通过将前两项相加来计算下一项。
    • firstTerm = secondTerm; secondTerm = nextTerm;：更新 firstTerm 和 secondTerm 以进行下一次迭代。
    • scanner.close();：关闭 Scanner 对象。

  4. 保存 Fibonacci.java 文件（Ctrl+S 或 Cmd+S）。

  5. 现在，在终端中使用 javac 命令编译 Java 程序：

    javac Fibonacci.java

    如果没有错误，此命令将在 ~/project 目录中创建一个 Fibonacci.class 文件。

  6. 最后，使用 java 命令运行编译后的程序：

    java Fibonacci

    程序将提示你输入项数。输入一个数字（例如 10）并按回车键，即可查看斐波那契数列。

    Enter the number of terms for Fibonacci sequence: 10
Fibonacci sequence up to 10 terms:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34

你已经成功编写、编译并运行了一个 Java 程序来生成斐波那契数列！

检查数字是否存在于数列中

在这一步，我们将修改 Java 程序，以检查给定的数字是否存在于生成的斐波那契数列中。这需要添加逻辑，在生成数列各项时，将用户输入的数字与数列中的项进行比较。

  1. 在 WebIDE 编辑器中打开 Fibonacci.java 文件。

  2. 修改 main 方法，加入检查数字是否存在于序列中的逻辑。用以下代码替换现有的 main 方法：

    import java.util.Scanner;

public class Fibonacci {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the number of terms for Fibonacci sequence: ");
        int n = scanner.nextInt();

        if (n <= 0) {
            System.out.println("Please enter a positive integer for the number of terms.");
            scanner.close();
            return; // Exit the program
        }

        System.out.print("Enter the number to check if it exists in the sequence: ");
        int checkNum = scanner.nextInt();

        System.out.println("Fibonacci sequence up to " + n + " terms:");

        int firstTerm = 0;
        int secondTerm = 1;
        boolean found = false;

        // Check the first two terms
        if (checkNum == firstTerm) {
            found = true;
        }
        System.out.print(firstTerm);

        if (n > 1) {
            if (checkNum == secondTerm) {
                found = true;
            }
            System.out.print(", " + secondTerm);
        }


        // Generate and check subsequent terms
        for (int i = 3; i <= n; ++i) {
            int nextTerm = firstTerm + secondTerm;
            if (checkNum == nextTerm) {
                found = true;
            }
            System.out.print(", " + nextTerm);
            firstTerm = secondTerm;
            secondTerm = nextTerm;
        }
        System.out.println(); // Print a newline at the end

        if (found) {
            System.out.println(checkNum + " exists in the Fibonacci sequence.");
        } else {
            System.out.println(checkNum + " does not exist in the Fibonacci sequence.");
        }

        scanner.close();
    }
}

    以下是修改内容的详细说明：

    • 我们添加了一个提示，询问用户想要检查的数字 (System.out.print("Enter the number to check..."))。
    • 我们将这个数字读取到一个新变量 checkNum 中 (int checkNum = scanner.nextInt();)。
    • 一个布尔型变量 found 被初始化为 false。这个变量将用于跟踪数字是否在序列中被找到。
    • 在循环之前，我们检查 checkNum 是否等于 firstTerm 或 secondTerm。
    • 在 for 循环内部，计算出 nextTerm 后，我们检查 checkNum 是否等于 nextTerm。如果相等，我们将 found 设置为 true。
    • 循环结束后，我们使用一个 if-else 语句，根据 found 变量的值，输出数字是否被找到。

  3. 保存 Fibonacci.java 文件。

  4. 在终端中编译修改后的程序：

    javac Fibonacci.java

  5. 运行编译后的程序：

    java Fibonacci

    现在，程序会先要求输入项数，然后要求输入要检查的数字。

    示例 1（数字存在）：

    Enter the number of terms for Fibonacci sequence: 10
Enter the number to check if it exists in the sequence: 8
Fibonacci sequence up to 10 terms:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34
8 exists in the Fibonacci sequence.

    示例 2（数字不存在）：

    Enter the number of terms for Fibonacci sequence: 10
Enter the number to check if it exists in the sequence: 10
Fibonacci sequence up to 10 terms:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34
10 does not exist in the Fibonacci sequence.

你已经成功修改程序，能够检查一个数字是否是生成的斐波那契数列的一部分。

使用数学公式进行优化

在前面的步骤中，我们通过迭代的方式生成了斐波那契数列，并通过将一个数字与数列的每一项进行比较来检查它是否存在。对于非常大的数字，生成整个数列可能效率较低。在这一步中，我们将探索斐波那契数的一个数学特性，它使我们无需生成数列就能检查一个数字是否为斐波那契数。

一个正整数 x 是斐波那契数，当且仅当 5*x^2 + 4 或 5*x^2 - 4 是一个完全平方数。完全平方数是一个整数的平方（例如，4 是一个完全平方数，因为它等于 2 * 2）。

我们将创建一个新的 Java 程序，使用这个公式来检查一个数字是否为斐波那契数。

  1. 在 ~/project 目录中创建一个名为 CheckFibonacci.java 的新文件。

  2. 打开 CheckFibonacci.java 并复制粘贴以下 Java 代码：

    import java.util.Scanner;

public class CheckFibonacci {

    // Function to check if a number is a perfect square
    public static boolean isPerfectSquare(int n) {
        if (n < 0) {
            return false;
        }
        int sqrt = (int) Math.sqrt(n);
        return (sqrt * sqrt == n);
    }

    // Function to check if a number is a Fibonacci number
    public static boolean isFibonacci(int n) {
        // n is Fibonacci if 5*n^2 + 4 or 5*n^2 - 4 is a perfect square
        return isPerfectSquare(5 * n * n + 4) ||
               isPerfectSquare(5 * n * n - 4);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a number to check if it is a Fibonacci number: ");
        int num = scanner.nextInt();

        if (isFibonacci(num)) {
            System.out.println(num + " is a Fibonacci number.");
        } else {
            System.out.println(num + " is not a Fibonacci number.");
        }

        scanner.close();
    }
}

    让我们看看这段代码的新部分：

    • public static boolean isPerfectSquare(int n)：这是一个辅助函数，它接受一个整数 n，如果 n 是完全平方数，则返回 true，否则返回 false。它计算整数平方根，并检查其平方是否等于原数。
    • public static boolean isFibonacci(int n)：这个函数实现了数学公式。它计算 5*n*n + 4 和 5*n*n - 4，并使用 isPerfectSquare 函数来检查这两个结果是否有一个是完全平方数。|| 运算符表示“或”。
    • main 方法现在会提示你输入一个数字，调用 isFibonacci 函数，并输出结果。

  3. 保存 CheckFibonacci.java 文件。

  4. 在终端中编译新程序：

    javac CheckFibonacci.java

  5. 运行编译后的程序：

    java CheckFibonacci

    程序会要求你输入一个数字。输入一个数字（例如 13）并按回车键。

    示例 1（斐波那契数）：

    Enter a number to check if it is a Fibonacci number: 13
13 is a Fibonacci number.

    示例 2（非斐波那契数）：

    Enter a number to check if it is a Fibonacci number: 10
10 is not a Fibonacci number.

与生成直到该数字的数列相比，这种方法在检查单个大数字是否为斐波那契数时效率要高得多。

总结

在这个实验中，我们学习了如何在 Java 中检查一个数字是否为斐波那契数。我们首先使用简单的迭代方法生成了指定项数的斐波那契数列。这需要理解斐波那契数列的定义，并实现计算和输出各项的逻辑。

接下来，我们探讨了如何检查给定的数字是否存在于生成的斐波那契数列中。最后，我们学习了一种优化方法，即使用数学公式来高效地判断一个数字是否为斐波那契数，而无需显式地生成整个数列。这需要理解斐波那契数的特性，并应用该公式进行检查。

相关 Java 课程
Java 入门

Java 入门

java
Java 编程练习

Java 编程练习

java
批量插入数据到课程表

批量插入数据到课程表

java