Java数据结构与算法———（54）斐波那契查找法

斐波那契查找法，也成为黄金分割查找法，也是基于二分查找法改进而成，主要也是改进了mid的求解公式/

一、代码

import java.util.Arrays;

/**
 * 斐波那契查找也是二分查找的改进版，也是改进了 mid 的求解公式
 * @author Lee
 *
 */
public class FibonacciSearch {

	public static int maxSize = 20;//斐波那契数列的大小
	public static void main(String[] args) {
		int[] arr = {1, 8, 10, 89, 1000, 1234};
		System.out.println("index = " + fibonacciSearch(arr, 1234));
	}
	
	//因为mid = low + F(k-1) - 1中需要用到斐波那契数列，所以先构造一个斐波那契数列
	//用非递归的方式得到一个斐波那契数列
	public static int[] fibonacci() {
		int[] f = new int[maxSize];
		f[0] = 1;
		f[1] = 1;
		for(int i = 2; i < maxSize; i++) {
			f[i] = f[i - 1] + f[i - 2];
		}
		return f;
	}
	
	//斐波那契查找算法
	//使用非递归的方法
	/**
	 * 
	 * @param arr 原数组
	 * @param key 待查找的值
	 * @return 找到了就返回下标，没找到就返回-1
	 */
	public static int fibonacciSearch(int[] arr, int key) {

		int low = 0;
		int high = arr.length - 1;// high一直没有变动
		int k = 0;// 表示斐波那契分割数值的下标，关键就是求这个 k 的值
		int mid = 0;// 存放 mid 的值
		int[] f = fibonacci();// 获得一个有20个值得斐波那契数列

		// 获取斐波那契分割数值的下标 k
		// 当high 小于等于 f[k] - 1 时，对应的 k 就是需要找的 k
		while (high > f[k] - 1) {
			k++;
		}
		// 因为 f[k] 值可能大于原数组arr的长度，因此需要使用Arrays类，构造一个新的数组temp，并指向原数组arr
		// Arrays.copyOf(arr, f[k]) 返回一个与arr类型相同的数组，如果f[k]大于arr.length，多出的数组元素会填充0，而此处需要使用数组arr最后的数填充temp
		//举例：
		//arr = {1, 8, 10, 89, 1000, 1234}
		//temp = {1, 8, 10, 89, 1000, 1234, 0, 0, 0} => {1, 8, 10, 89, 1000, 1234, 1234, 1234}
		int[] temp = Arrays.copyOf(arr, f[k]);
		// 使用数组arr最后的数填充temp
		for (int i = high + 1; i < temp.length; i++) {
			temp[i] = arr[high];
		}

		//使用while循环来处理，找到数组arr中等于 key 值的下标
		while(low <= high) {//只要这个条件满足，就一直找
			mid = low + f[k - 1] - 1;
			if(key < temp[mid]) {//说明需要继续向数组temp的左边（前面）查找
				high = mid - 1;
				//说明：k--
				// 1. 全部元素 = 前面的元素 + 后面的元素
				// 2. f[k] = f[k-1] + f[k-2]
				// 3. 因为前面有f[k-1]个元素，所以可以继续拆分成f[k-1] = f[k-2] + f[k-3]
				// 4. 即在f[k-1]的前面继续查找，即 k--
				// 5. 即下次循环时 mid = low + f[k-1-1] - 1
				k--;
			}else if(key > temp[mid]) {//说明要向temp数组的后面查找（右边）
				low = mid + 1;
				//说明：k -= 2
				// 1. 全部元素 = 前面的元素 + 后面的元素
				// 2. f[k] = f[k-1] + f[k-2]
				// 3. 因为后面有f[k-2]个元素，所以可以继续拆分成f[k-2] = f[k-3] + f[k-4]
				// 4. 即在f[k-2]的后面进行查找，即 k -= 2
				// 5. 即下次循环时，mid = low + f[k-1-2] - 1
				k -= 2;
			}else {//找到了
				//需要确定，返回的是哪个下标
				if(mid < high) {
					return mid;//返回小的
				}else {
					return high;//返回小的
				}
			}
		}
		//当上面的while循环没有返回值时，说明没找，返回-1
		return -1;
	}

}

二、结果

1. 查找 1234

index = 5

2. 查找 1

index = 0

2. 查找 89

index = 3