常用的查找算法有四种：

1、线性（顺序）查找

  遍历数组+比较的思想。

package com.huey.search;

public class SeqSearch {
    
    

	public static void main(String[] args) {
    
    
		int[] arr = {
    
     2, 43, -23, 233, 94, 929, 82 };
		int index = seqSearch(arr, -23);
		if (index == -1) {
    
    
			System.out.println("没找到~");
		} else {
    
    
			System.out.println("找到了，下标为：" + index);
		}
	}

	// 这里实现的线性查找是找到一个满足条件的值就返回，想要返回全部的就使用集合，返回一个集合。
	public static int seqSearch(int[] arr, int value) {
    
    
		// 线性查找就是逐一比对，发现相同值，就返回下标
		for (int i = 0; i < arr.length; i++) {
    
    
			if (arr[i] == value) {
    
    
				return i;
			}
		}
		return -1;
	}

}

  输出结果：

2、二分（折半）查找

1）第一种（帮助理解算法，待优化）

  这里使用递归的思想。

  需要注意的是：使用二分查找的前提是这组序列有序的。

  现有数组 arr = {1, 8 , 10 , 89 , 1000 , 1234};

  下面以查找 89 为例：

二分查找代码：

package com.huey.search;

//注意：使用二分查找的前提是，该数组是有序的
public class BinarySearch {
    
    

	public static void main(String[] args) {
    
    
		int[] arr = {
    
     1, 8, 10, 89, 1000, 1234 };
		int resIndex = binarySearch(arr, 0, arr.length - 1, 89);
		System.out.println("resIndex = " + resIndex);
	}

	// 二分查找算法
	/**
	 * @param arr     数组
	 * @param left    左边的索引
	 * @param right   右边的索引
	 * @param findVal 要查找的值
	 * @return 如果找到就返回下标，没找到就返回-1
	 */
	public static int binarySearch(int[] arr, int left, int right, int findVal) {
    
    

		// 因为数组是引用类型，所以递归时一直在用一个数组
		// 当left>right时，说明递归整个数组，但是没有找到
		if (left > right) {
    
    
			return -1;
		}
		int mid = (left + right) / 2;
		int midVal = arr[mid];

		if (findVal > arr[mid]) {
    
    
			// 向右递归
			return binarySearch(arr, mid + 1, right, findVal);
		} else if (findVal < arr[mid]) {
    
    
			// 向左递归
			return binarySearch(arr, left, mid - 1, findVal);
		} else {
    
    
			return mid;
		}
	}

}

  上面的代码无法把多个相同的数值，全部查找出来，比如：{1, 5, 16, 76, 666, 666, 666, 3224} 中的666.

2）第二种（优化后）

  下面来解决这个问题，需要注意的是二分查找的前提条件是这序列是有序的。所以若有多个相同的数，则它们都是相邻的。

  在讲解思路之前先引入一个小知识。

包装类

  Java是一种面向对象语言，很多地方需要使用对象而非基本数据类型。比如，在集合类中，因为集合的容器要求元素是 Object 类型。所以，我们是无法将int 、float等类型放进去的。

  为了让基本数据类型也具有对象的特征，就出现了包装类型。它相当于将基本数据类型“包装起来”，使其具有了对象的性质，并且为其添加了属性和方法，丰富了基本数据类型的操作。

装箱、拆箱

  日常使用中，基本数据类型和包装类有时是需要转换的，例如把int 转换成包装类Integer 对象。

  所谓装箱（boxing），即把基本数据类型转换成包装类；

  拆箱（unboxing），即把包装类转换成基本数据类型；

  在Java 5 之前，要进行装箱需要如下语句：

Integer i = new Integer(6);

自动拆箱、装箱

  Java 5中，提供了自动装箱功能。

  所谓自动，即二者之间会自动转换，提升了开发效率。

  所以，

  自动装箱，即把基本数据类型自动转换成包装类；

  自动拆箱，即把包装类自动转换成基本数据类型；

Integer i = 6; // 自动装箱，6是int 类型。int => Integer
int j = i; // 自动拆箱，i 是Integer 类型。Integer => int

  Integer i = 6 可以替代 Integer i = new Integer(6);

  这便是自动装箱功能的好处。

  下面可以开始改进算法了！

  思路分析：在 else 语句中
   1. 在找到 mid 索引值时，不要马上返回。
   2. 向mid 索引值的左边扫描，将所有满足 1000 的元素下标加入到集合ArrayList。
   3. 向mid 索引值的右边扫描，将所有满足 1000 的元素下标加入到一个集合中ArrayList。
   4. 将ArrayList 返回。

	public static ArrayList<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {
    
    
		// 因为数组是引用类型，所以递归时一直在用一个数组
		// 当left>right时，说明递归整个数组，但是没有找到
		if (left > right) {
    
    
			return null;
		}
		int mid = (left + right) / 2;
		int midVal = arr[mid];

		if (findVal > arr[mid]) {
    
    
			// 向右递归
			return binarySearch2(arr, mid + 1, right, findVal);
		} else if (findVal < arr[mid]) {
    
    
			// 向左递归
			return binarySearch2(arr, left, mid - 1, findVal);
		} else {
    
    

			ArrayList<Integer> resIndexList = new ArrayList<Integer>();
			// 向mid 索引值的左边扫描，将所有满足 1000 的元素下标加入到集合ArrayList。
			int temp = mid - 1;
			while (true) {
    
    
				if (temp < 0 || arr[temp] != findVal) {
    
    // 退出
					break;
				}
				// 否则就把temp 放入集合ArrayList中
				resIndexList.add(temp);// 使用自动装箱的功能
				temp -= 1;// 左移
			}
			resIndexList.add(mid);// 中间的
			// 向mid 索引值右边扫描，将所有满足 1000 的元素下标加入到集合ArrayList。
			temp = mid + 1;
			while (true) {
    
    
				if (temp > arr.length - 1 || arr[temp] != findVal) {
    
    
					break;
				}
				resIndexList.add(temp);
				temp += 1;
			}
			return resIndexList;
		}

	}

测试：

输出：

3、插值查找

1）原理：线性插值

  这个式子的意义：所预测的数字的位置占数组总长度的比例。

  其中，

  可以理解成两根线段，要找的这个值在总线段上，把这个值减去左边界再除以总线段的长度，就得到了他占总长度的几分之几，乘以总长度就得到了。

  公式可以理解成百分比查找，因为是顺序的所以left端是最小值，key-a[left]是目标距离left的距离，a[right]-a[left]是整体距离，相除就是key在整体有序数列中大致的位置

2）举例说明：1~100的数组

代码：

package com.huey.search;

public class InsertValueSearch {
    
    

	public static void main(String[] args) {
    
    
		int[] arr = new int[100];
		for (int i = 0; i < 100; i++) {
    
    
			arr[i] = i + 1;
		}

		int index = insertValueSearch(arr, 0, arr.length - 1, 73);
		System.out.println("index = " + index);
	}

	// 插值查找算法
	// 说明：插值查找算法也要求数组是有序的。
	/**
	 * @param arr     数组
	 * @param left    左边的下标
	 * @param right   右边的索引
	 * @param findVal 查找值
	 * @return 如果找到，就返回对应的下标；没找到就返回-1
	 */
	public static int insertValueSearch(int[] arr, int left, int right, int findVal) {
    
    
		System.out.println("被调用了~");

		if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
    
    
			// 第一个条件用来终止递归；后两个条件防止越界
			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, mid + 1, right, findVal);
		} else if (findVal < midVal) {
    
    // 说明应该向左递归查找
			return insertValueSearch(arr, left, mid - 1, findVal);
		} else {
    
    
			return mid;
		}
	}

}

测试：

相比之下，若通过折半查找，则需要多次递归。

3）注意事项

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

4、斐波那契查找

1）简介

  黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。其比值是一个无理数，用分数表示为(√5-1)/2，取其前三位数字的近似值是0.618。

  由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这个分割点就叫做黄金分割点（golden section ratio），通常用Φ表示。这是一个十分有趣的数字，以0.618来近似表示，通过简单的计算就可以发现：(1-0.618)/0.618≈0.618，即一条线段上有两个黄金分割点。

所以，考了61分，才是最棒的分数~

斐波那契数列{1，1，2，3，5，8，13，21，34，55…}

其中，越往后，两个相邻数的比值就越无限接近黄金分割值0.618

2）斐波那契（黄金分割法）查找原理

先给出问题：

请对一个有序数组进行斐波那契查找{1，8，10，89，1000，1234}，找到数则返回其下标，没找到就返回-1.

  和前两种类似，仅改变了中间节点（mid）的位置，mid不再是中间或插值得到，而是位于黄金分割点附近，即mid = low + F(k-1) - 1（F代表斐波那契数列），如下图所示：

理解：

  F(k) - 1之所以减1，因为是数组从0开始，长度与索引的关系。

  斐波那契数组是一个工具，帮助找到黄金分割点，仅此而已。想要使用这个工具就得符合这个工具的要求（也就是对自己的数组长度进行修改）。

  因为f[k] （黄金分割点处对应的Fibonacci数列的值，例如： f[5 ]对应的就是8）可能大于 数组 a 的长度，因此我们需要使用Arrays类，构造一个新的数组，并保存到 temp 数组中。 不足的部分会使用0填充。

  实际使用时，需要使用 a 数组最后的数填充 temp.

  修改完毕后，这个工具的用法就是调用那个公式帮你找到mid（黄金分割点）。

  相比前两种算法，这个算法如此大费周章，优点在哪呢？

  优点在于用斐波那契数列通过一个while循环来取代递归，提高了效率。

  对于这个while 循环内部的条件这里作一些说明：

		while (low <= high) {
    
     // 只要这个条件满足，就可以找
			mid = low + f[k - 1] - 1;// mid不管向前还是向后，始终都是黄金分割点!!!!
			if (key < temp[mid]) {
    
    // 说明我们应该继续向数组的前面查找
				high = mid - 1;
				// 说明：
				// 1.全部元素 = 前面的元素+后面元素
				// 2.f[k] = f[k-1] + f[k-2]
				// 3.因为前面有f[k-1]个元素，所以可以继续拆分 f[k-1] = f[k-2] + f[k-3]
				// 即在f[k-1]的前面继续查找 k--
				// 下次循环的时候 mid = f[k-1-1] - 1
				k--;
			} else if (key > temp[mid]) {
    
    // 我们应该向数组的后边查找
				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]
				// 即在f[k-2]的前面继续查找 k-=2
				// 下次循环的时候 mid = f[k-1-2] - 1
				k -= 2;
			} else {
    
    // 找到
					// 需要确定，返回的是哪个下标
				if (mid <= high) {
    
    
					return mid;
				} else {
    
    // 因为temp是扩充过的，所以mid会大于high
					return high;// 此时mid已经越界，返回原数组边界high
				}
			}
		}

第一个判断语句，向mid（黄金分割点）左边查找：

因为前面有f[k-1]个元素，所以需要进行拆分：f[k-1] = f[k-2] + f[k-3]

后面亦同理，继续拆分：f[k-2] = f[k-3] + f[k-4]

完整代码：

package com.huey.search;

import java.util.Arrays;

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 = " + fibSearch(arr, 1234));// 5
	}

	// 因为后面我们mid = low+F(k-1)-1，需要使用到Fibonacci数列，因此我们需要先获取到一个Fibonacci数列。
	// 非递归的方式得到一个Fibonacci数列
	public static int[] fib() {
    
    
		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;
	}

	// 编写Fibonacci查找算法
	// 非递归的方式
	/**
	 * @param a   数组
	 * @param key 需要查找的关键码（值）
	 * @return 返回其下标，若没有就返回-1
	 */
	public static int fibSearch(int[] a, int key) {
    
    
		int low = 0;
		int high = a.length - 1;
		int k = 0;// 表示Fibonacci分割数值的下标
		int mid = 0;// 存放黄金分割点 mid 的值
		int f[] = fib();// 获取到Fibonacci数列
		// 获取到Fibonacci数列分割数值的下标
		while (high > f[k] - 1) {
    
    // 条件满足说明还没找到k。(f[k]-1是最后一个元素的下标）
			k++;
		} // 退出while 说明找到k了，此时k为5，f[k]为8，也就是下面temp数组的长度。
			// 因为f[k] 值 可能大于 数组的长度，因此我们需要使用Arrays类，构造一个新的数组，并指向temp[]
			// 不足的部分会使用0填充
		int[] temp = Arrays.copyOf(a, f[k]);
		// 实际上需要使用a 数组最后的数填充 temp
		// 举例：
		// tmep = {1,8,10,89,1000,1234,0,0} => {1,8,10,89,1000,1234,1234,1234}
		for (int i = high + 1; i < temp.length; i++) {
    
    
			temp[i] = a[high];
		}
		// 使用while来循环处理，找到key
		while (low <= high) {
    
     // 只要这个条件满足，就可以找
			mid = low + f[k - 1] - 1;// mid不管向前还是向后，始终都是黄金分割点!!!!
			if (key < temp[mid]) {
    
    // 说明我们应该继续向数组的前面查找
				high = mid - 1;
				// 说明：
				// 1.全部元素 = 前面的元素+后面元素
				// 2.f[k] = f[k-1] + f[k-2]
				// 3.因为前面有f[k-1]个元素，所以可以继续拆分 f[k-1] = f[k-2] + f[k-3]
				// 即在f[k-1]的前面继续查找 k--
				// 下次循环的时候 mid = f[k-1-1] - 1
				k--;
			} else if (key > temp[mid]) {
    
    // 我们应该向数组的后边查找
				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]
				// 即在f[k-2]的前面继续查找 k-=2
				// 下次循环的时候 mid = f[k-1-2] - 1
				k -= 2;
			} else {
    
    // 找到
					// 需要确定，返回的是哪个下标
				if (mid <= high) {
    
    
					return mid;
				} else {
    
    // 因为temp是扩充过的，所以mid会大于high
					return high;// 此时mid已经越界，返回原数组边界high
				}
			}
		}
		return -1;
	}

}

测试：