查找算法之三：斐波那契查找（黄金分割法）

思路分析

FibonacciSearch（也叫黄金分割法）的思路分析：

• ==>实际上，这也是一个基于二分查找（也就是折半查找）的查找算法。只是在计算mid 的值时，加入了斐波那契数列的性质在里边：
  1、由于斐波那契数列中，后一个元素与前一个元素之比，接近于0.618的黄金分割比例，
  该查找算法就借助斐波那契数列来帮助每一次mid的确认【mid取的是：无限接近于黄金分割点的位置的坐标】
  2、因为斐波那契数列的迭代公式为：f(k) = f(k-1) + f(k-2);
  所以，有：f(k) - 1= f(k-1) - 1 + f(k-2) - 1 + 1;
  所以，当数组的元素有f(k) - 1个时，
  mid = left + f(k-1) - 1;【mid的前边有f(k-1) - 1个元素，后边有f(k-2) - 1个元素】
  然后，再进行下一轮循环计算，mid将该序列划分为两个序列：f(k-1) - 1、f(k-2) - 1，正好同样可以进行斐波那契分割
  ···
  ------> 直至某一次循环时， midVal == findVal，找到了要查找的数；
  或者，到最终，left > right，结束循环，并没有找到要查找的数。
  3、由于arr.length 不一定就恰好等于某一个f(k) - 1，所以当它们不相等的时候，我们要对arr[]进行扩容：
  定义一个数组temp[]，先将arr[] copy到temp[]中，
  然后将temp[arr.length]直到temp[temp.length-1]的元素赋值为arr[arr.length-1]。
  == >这是因为只有temp.length == f(k) - 1时，才可以保证根据斐波那契数列可以获得准确的 mid值【mid所在的位置，无限接近于“黄金分割点”】。
  同时将多余的元素都赋值为arr[arr.length-1]，则是保证数组在扩容的同时仍能够保证它的 有序性。

代码实现

public class FibonacciSearch {

	static int maxSize = 20;//先定为20
	
	//将fib[]填充完整
	public static int[] fib() {
		int[] fib = new int[maxSize];//1,1,2,3,5,8,13,21,34,55
		fib[0] = 1;
		fib[1] = 1;
		
		for (int i = 2; i < fib.length; i++) {
			fib[i] = fib[i-1] + fib[i-2];
		}
		return fib;
	}
	
	public static void main(String[] args) {
		
		
		int[] arr = new int[]{1,4,7,10,16};
		
		int search = fibSearch(arr, 16);
		System.out.println(search);
		
	}
	
	//实现查找的算法
	/**
	 * 
	 * @param arr 待查找的数组
	 * @param left 待查找序列的左索引边界值
	 * @param right 待查找序列的右索引边界值
	 * @param findVal 待查找的值
	 * @param k 该待查找序列的mid 对应的斐波那契数列中的索引值
	 * @return
	 */
	public static int fibSearch(int[] arr,int findVal) {
		//先确定查找需要的边界值
		int left = 0;
		int right = arr.length-1;
		int mid = 0;
		int k = 0;
		int[] fib = fib();//先将斐波那契数列的值完善好
		
		//找到该数组对应的k值
		while(right+1 > (fib[k] - 1)) {
			k++;
		}
		
		//依据k的值，对arr[]进行扩容temp[]
		int[] temp = Arrays.copyOf(arr, fib[k]-1);//因为扩容后的 数组的长度应该为fib[k]-1
		for (int i = right+1; i < temp.length; i++) {
			temp[i] = arr[right];
		}
		
		while(left <= right) {
			
			mid = left + fib[k-1] -1;
			int midVal = temp[mid];
			
			if(findVal < midVal) {//向左查找
				right = mid-1;
				k-=1;
			}else if(findVal > midVal) {//向右查找
				left = mid+1;
				k-=2;
			}else {//找到了
				//需要判断：此时的mid与arr.length-1的关系
				//即：找到的是arr[]本来的元素，还是扩容之后的元素
				//总之，需要输出的是arr[]中存在的下标值
				//不然，会造成：下标“越界”
				return (mid>arr.length-1)? arr.length-1:mid;
			}
		}
		return -1;//没找到
	}
}

---

坚持下去！