数据结构与算法-查找算法(二分查找，插值查找，斐波那契(黄金分割法)查找)

查找算法

• 以下三种算法的基本思想相同，都是利用递归来寻找

二分查找

• 思路分析

1.首先确定该数组的中间下标，min = (left + right) / 2
2.然后让需要查找的的数findVal和arr[min]比较
(1)findVal > arr[mid],说明n你要查找的数在mid的右边，递归向右查找
(2)findVal < arr[mid],说明n你要查找的数在mid的左边，递归向左查找 找到数，直接返回
(3)递归完整个数组，任然没找到finVal，结束递归，此时left > right

• 代码实现

public class BinarySearch {
	public static void main(String[] args) {

		int[] arr = {1, 2, 2, 3, 7, 8, 9, 13, 14, 14, 14, 15};
		int index = binarySearch(arr, 0, arr.length-1, 13);
		System.out.println(index);
	}
	
	/**
	 * 
	 * @param arr  数组
	 * @param left  左边的索引
	 * @param right  右边的索引
	 * @param findVal  查找的值
	 * @return 如果找到返回查找的下标，未找到返回-1
	 */
	public static int binarySearch(int arr[], int left, int right, int findVal) {
		
		int mid = (left + right) / 2;
		int midVal = arr[mid];
		
		//left > right,此时递归完毕，未找到，返回-1
		if (left > right) {
			return -1;
		}
		
		if (findVal < midVal) {
			//左递归
			return binarySearch(arr, left, mid - 1, findVal);
		} else if (findVal > midVal) {
			//右递归
			return binarySearch(arr, mid + 1, right, findVal);
		} else {
			return mid;
		}
	}
}

插值查找算法

• 插值查找原理

(1)插值查找算法类似于二分查找，不同的是插值查找每次从自适应mid处开始查找
(2)将折半查找中求mid的索引公式修改为 ，low表示左边索引left，high表示右边索引right
(3)Int midIndex = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low]) -> 插值索引

• 注意

(1)对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找，速度比较快
(2)关键字分布不均匀的情况下，该方法不一定比二分查找要好

• 代码实现

public class InsertValueSearch {

	public static int count = 0;
	
	public static void main(String[] args) {
		
		int[] arr = {0, 580, 590, 600, 612, 630, 640, 680, 700, 750};
		int index = insertValueSearch(arr, 500);
		System.out.println(index);
	}

	//插值查找算法也要求数组有序
	public static int insertValueSearch(int arr[], int findVal) {
		int index = insertValueSearch(arr, 0, arr.length-1, findVal);
		return index;
	}
	
	/**
	 * 插值查找
	 * @param arr 查找数组
	 * @param left 传入左下标
	 * @param right 传入右下标
	 * @param findVal 寻找的值
	 * @return
	 */
	public static int insertValueSearch(int arr[], int left, int right, int findVal) {
		
		System.out.println("第" + ++count + "次查找!");
		if (left > right 
				|| findVal < arr[0] 
				|| findVal > arr[arr.length-1] 
				|| findVal < arr[left] /*右递归时findVal小于第一个数，未找到*/
				|| findVal > arr[right] /*左递归时findVal大于第一个数，未找到*/
			) {
			return -1;
		}
		
		//求出mid
		int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
		int midVal = arr[mid];
		if (findVal < midVal) {
			//左递归
			return insertValueSearch(arr, left, mid - 1, findVal);
		} else if (findVal > midVal) {
			//右递归
			return insertValueSearch(arr, mid + 1, right, findVal);
		} else {
			return mid;
		}
		
	}
}

斐波那契(黄金分割法)查找算法

• 黄金分割点是指把一条线段分割成两部分，使其一部分与全场之比等于另一部分与这部分之比，娶其前三位近似值是0.618，由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中介比。

• 代码实现

public class FibonacciSearch {

	public static void main(String[] args) {
		
		int[] arr = {1, 8, 10, 89, 1000, 1234};
		int index = fibSearch(arr, 1000);
		System.out.println(index);
	}

	//因为我们 mid=low+F(k-1)-1,需要使用到斐波那契数列，因此我们需要先获取到斐波那契数列
	//非递归方式得到斐波那契数列
	public static int[] fib(int count) {

		int num = count;
		if (count < 4) num = 4; 
		
		int[] arr = new int[num];
		arr[0] = 1;
		arr[1] = 1;
		for (int i = 2; i <num; i++) {
			arr[i] = arr[i-1] +arr[i-2];
		}
		return arr;
	}
	
	/**
	 * 
	 * @param arr 数组
	 * @param key 我们要查找的值
	 * return 返回下标，未找到返回-1
	 */
	public static int fibSearch(int arr[], int key) {
		
		int low = 0;
		int high = arr.length - 1;
		int k = 0;  //表示斐波那契分割数值的下标
		int mid = 0; //存放mid值
		
		int[] fib = fib(arr.length);  //获取到斐波那契数组
		
		while (high > fib[k] - 1) {
			k++;
		}
		
		//因为fib[k]可能大于arr的长度，因此我们需要使用Arrays类，构造一个新的数组并指向temp
		int[] temp = Arrays.copyOf(arr, fib[k]);
		//实际上，需要使用arr数组的最后的数填充temp
		for (int i = high + 1; i < temp.length; i++) {
			temp[i] = arr[high];
		}
		
		//用while来循环处理，找到我们数的key
		while (low <= high) {
			mid = low + fib[k-1] - 1;
			if (key < temp[mid]) {  //我们应该继续向数组的前面查找
				high = mid - 1;
				//1.全部的元素 = 前面的元素 + 后边的元素
				//2.f[k] = f[k-1] + f[k-2]
				//因为前面有f[k-1]个元素，所以可以继续拆分-> f[k-1] = f[k-2] + f[k-]
				//即在f[k-1]的前面继续查找 k--
				//即下次循环 mid = f[k-1] - 1
				k--;  
			} else if (key > temp[mid]) {//我们应该继续向数组的后面查找
				low = mid + 1;
				//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 = f[k - 1 - 2] - 1
				k -= 2;
			} else {
				//需要确定返回的下标
				//如果返回的值为最后一位数，可能存在超出数组长度的下标
				if (mid <= high) {
					return mid;
				} else {
					return high;
				}
			}
		}
		
		return -1;
		
	}
}

------此文章总结改造来自韩顺平老师讲解的java数据结构与算法