Java斐波那契查找知识点(含面试大厂题和源码)

斐波那契查找（Fibonacci Search）是一种在有序数组中查找元素的高效算法，它基于斐波那契数列的性质。斐波那契查找是二分查找的一种改进，通过使用斐波那契数列来确定搜索范围，可以在某些情况下减少比较次数，特别是在数组较大时表现更为出色。

以下是斐波那契查找的一些关键知识点：

1. 斐波那契数列:

   • 斐波那契数列是一个递归数列，其中每个数字是前两个数字的和，即F(n) = F(n-1) + F(n-2)，起始值为F(0) = 0和F(1) = 1。
   • 数列的前几个数字是0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …。
   • 斐波那契数列的一个特性是，对于任意大于2的n，F(n)都大于F(n-1) + F(n-2)。

2. 斐波那契查找的原理:

   • 斐波那契查找的基本思想是利用斐波那契数列的特性来确定搜索区间的边界。
   • 算法从最小的斐波那契数开始，该数小于或等于数组的长度，并尝试找到一个大于或等于给定值的元素。
   • 如果找不到，算法会递减到前两个斐波那契数，并继续搜索。

3. 算法步骤:

   • 初始化两个斐波那契数FibMMm2和FibMM1，其中FibMMm2是大于或等于数组长度的最小斐波那契数，FibMM1是其前一个斐波那契数。
   • 计算偏移量offset，使得FibMM1 - offset是小于或等于数组长度的最大斐波那契数。
   • 根据偏移量和给定值在数组中计算一个索引i，并与数组中的元素进行比较。
   • 如果找到元素，则返回索引；如果给定值较大，则在右侧子数组中继续查找；如果给定值较小，则在左侧子数组中查找。
   • 重复上述步骤，直到找到元素或区间缩小到0。

4. 时间复杂度:

   • 斐波那契查找的时间复杂度大约是O(log n)，其中n是数组的长度。
   • 由于斐波那契数列的增长速度比二分查找中的2的幂次方慢，因此在大型数组中斐波那契查找可能比二分查找更快。

5. 实现要点:

   • 需要一个函数来生成斐波那契数列，或者预先计算出一定范围内的斐波那契数。
   • 在查找过程中，需要仔细处理边界条件和偏移量的计算。

6. 适用场景:

   • 斐波那契查找适用于大型有序数组的查找问题。
   • 当数组的大小经常变化时，斐波那契查找可能不如二分查找高效，因为每次数组大小变化后都需要重新计算斐波那契数列。

通过掌握上述知识点，你可以有效地理解和实现斐波那契查找算法，并在需要时将其应用于解决实际问题。在面试中，你可能需要解释算法的工作原理、时间复杂度和适用场景，以及与二分查找的比较。

题目 1：实现斐波那契查找算法

描述：
给定一个有序数组和一个目标值，使用斐波那契查找算法找到目标值在数组中的位置。如果目标值不在数组中，返回-1。

要求：

• 有序数组中的元素可以是任何类型，但比较操作应该是有效的。
• 考虑到斐波那契数列的特性，算法应该尽量减少不必要的比较。

Java代码示例：

import java.util.Arrays;

public class FibonacciSearch {
    public static int fibonacciSearch(int[] arr, int x) {
        int fibMMm2 = 0, fibMM1 = 1, fibM = fibMMm2 + fibMM1;
        int offset = -1;

        // 找到小于等于数组长度的最大斐波那契数
        while (fibM < arr.length) {
            fibMMm2 = fibMM1;
            fibMM1 = fibM;
            fibM = fibMMm2 + fibMM1;
        }

        // 计算偏移量
        offset = (fibMM1 - 1) % arr.length;
        if (offset == 0) offset = arr.length;

        // 从最后一个斐波那契数开始查找
        for (int i = offset; i < arr.length; i++) {
            if (arr[i] == x) return i;
        }

        // 在前两个斐波那契数对应的区间内查找
        while (fibMM1 > 1) {
            if (arr[(i - fibMM2) % arr.length] == x) return (i - fibMM2 + offset) % arr.length;

            fibM = fibMM1 + fibMM2;
            fibMM2 = fibMM1;
            fibMM1 = fibM % arr.length;
        }

        return -1; // 如果没有找到目标值
    }

    public static void main(String[] args) {
        int[] arr = {10, 22, 35, 40, 45, 50, 80, 82, 85, 90, 100};
        int x = 85;
        int result = fibonacciSearch(arr, x);
        System.out.println("Element found at index: " + result);
    }
}

题目 2：找到有序数组中的倒数第二个元素

描述：
给定一个有序数组（可能包含重复元素），找到数组中的倒数第二个元素。

要求：

• 不使用数组的内置方法，如lastIndexOf。
• 考虑到数组可能非常大，算法应该尽量减少不必要的比较和操作。

Java代码示例：

public class SecondLastElement {
    public static int findSecondLast(int[] arr) {
        if (arr == null || arr.length < 2) {
            throw new IllegalArgumentException("Array should have at least two elements.");
        }

        int secondLast = -1;
        for (int i = 0; i < arr.length; i++) {
            if (i < arr.length - 2) {
                if (arr[i] != arr[i + 1]) {
                    secondLast = arr[i];
                }
            } else {
                return secondLast;
            }
        }

        return secondLast;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 5, 5, 6, 7};
        System.out.println("Second last element is: " + findSecondLast(arr));
    }
}

题目 3：验证一个字符串是否为另一个字符串的旋转

描述：
给定两个字符串，验证字符串B是否可以由字符串A旋转得到（例如，“waterbottle”旋转后可以变成“erbottlewat”，但“waterbottle”不能旋转成“bottlewater”）。

要求：

• 不使用额外的空间。
• 考虑到字符串可能非常长，算法应该尽量减少不必要的操作。

Java代码示例：

public class StringRotation {
    public static boolean isRotation(String A, String B) {
        if (A == null || B == null || A.length() != B.length()) {
            return false;
        }

        int count = 0;
        for (int i = 0; i < A.length(); i++) {
            if (A.charAt(i) == B.charAt(0)) {
                count++;
            }
        }

        // 如果A中B的首字符出现次数是A的长度，说明B是A的旋转
        return count == A.length();
    }

    public static void main(String[] args) {
        String A = "waterbottle";
        String B = "erbottlewat";
        System.out.println("Is B a rotation of A? " + isRotation(A, B));
    }
}

在面试中，除了提供解决方案的代码，还应该准备好解释你的算法思路、时间复杂度和空间复杂度。此外，讨论可能的边界情况和异常处理也是非常重要的。