查找算法概述
在Java中，常用的查找算法有四种：
1、顺序（线性）查找
2、二分查找/折半查找
3、插值查找
4、斐波那契查找
线程查找
线性查找概述
线性查找十分简单。
现在有一个数列，可以是有序的，可以是无序的。
我们从头到尾依次寻找，如果找到了那么提示找到并返回下标。
代码实现
/**
* 实现一个比较简答的线性查找，也就是说只查找一个值，这里就不写查找多个值的了，因为比较简单
*
* @param arr 要查找的数组
* @param val 要查找的值
* @return 查找到的值的下标，没有查到则返回-1
*/
public static int seqSearch(int[] arr, int val) {
int index = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == val) {
return i;
}
}
return index;
}
二分查找
线性查找概述
二分查找必须要在一个有序的数组中进行查找
有序的意思是：从大到小，或者从小到大都可以。
二分查找有两种
- 递归查找
- 非递归查找
二分查找的思想
1、确定好数组元素的中间下标：mid = (left + right) / 2
2、让需要查找的数findVal和arr[mid]比较
- 假如findVal > arr[mid]，那么说明findVal的下标在mid之后，那么向右边进行递归查找
- 假如findVal < arr[mid]，那么说明findVal的下标在mid之前，那么向左边进行递归查找
- 假如findVal == arr[mid]，说明查找到了内容
注意点
结束递归的条件
1、找到了对应的值，我们退出递归
2、所有的数据已经遍历完成，但是还没有找到数据，那么结束递归（这种情况也就是left指针 > right指针）
代码实现
- 基本的代码实现
/**
* 二分法查找，必须是一个有序数组才可以进行查找
*
* @param arr 要查找的数组
* @param left 左边的索引
* @param right 右边的索引
* @param findVal 要查找的元素
* @return
*/
public static int binarySeach(int[] arr, int left, int right, int findVal) {
/*
假如左边的指针比右边的指针大，那么说明没有找到最终的值，返回-1即可
*/
if (left > right) {
return -1;
}
/*
假如还在寻找的过程中，那么有如下三种情况：
*/
//中间索引
int mid = (left + right) / 2;
//中间值
int midVal = arr[mid];
//1、假如要查找的值>中间值，那么进行向右递归
if (findVal > midVal) {
return binarySeach(arr, mid + 1, right, findVal);
}
//2、假如要查找的治<中间值，那么进行向左递归
else if (findVal < midVal) {
return binarySeach(arr, left, mid - 1, findVal);
}
//3、剩下的一种情况就说明已经找到了对应的值，结束递归，返回对应的索引
else {
return mid;
}
}
- 二分查找的升级处理
需求：当我们的数组中存在多个相同的值时，如何将这多个相同的值都查到，而不是只返回一个
/**
* 二分查找，这里要进行一次升级，也就是将多个相同的值的索引放到List里面一块返回
*
* @param arr 要查找的数组
* @param left 左边的下标
* @param right 右边的下标
* @param findVal 要寻找的元素
* @return 要寻找的值的索引的集合，没有则返回null
*/
public static List<Integer> binarySearchUpgrade(int[] arr, int left, int right, int findVal) {
if (left > right) {
return null;
}
int mid = (left + right) / 2;
int midVal = arr[mid];
if (findVal > midVal) {
return binarySearchUpgrade(arr, mid + 1, right, findVal);
} else if (findVal < midVal) {
return binarySearchUpgrade(arr, left, mid - 1, findVal);
}
/*
前两个都没有什么区别，重点是这里
假如我们找到了一个和findVal相同的值，同时也获得了它的下标
那么根据有序排列的规则，这个下标的左右两边很可能是相同的个数字，所以要分别对左右两边进行遍历，直到找到下标不是为止
而且注意，根据有序排列的规则，二分查找的肯定是有序的，不会存在1，1000,200这种情况
*/
else {
//0、创建一个List集合，加入已经确认的下标
List list = new ArrayList();
list.add(mid);
//1、获取数组元素对应的下标
int temp = mid - 1;
//2、向左进行遍历，寻找对应值的下标，加入到集合中
while (temp >= 0 && arr[temp] == midVal) {
list.add(temp--);
}
//3、重置下标
temp = mid + 1;
//4、向右进行遍历，寻找对应值的下标，加入到集合中
while (temp <= arr.length - 1 && arr[temp] == midVal) {
list.add(temp++);
}
//5、集合进行排序
Collections.sort(list);
return list;
}
}
插值查找
插值查找概述
插值查找是二分查找的一种更进一步的优化方案，与二分查找不同的是：插值查找的中间点mid是自适应的
我们在二分查找的时候，中间的点是(left + right)/2得到的
但是假如使用插值查找，那么中间的点是 left + (right - left) x (findVal - arr[left]) / (arr[right] - arr[left])
这个公式也就是拉格朗日插值（注意，数字必须是有序的，才能使用这个公式）
那么其实插值算法最重要的思想就是这个mid的公式，但是这方面确实涉及到了一些数学的知识
还是记忆下：
left：在数组中，就代表0
right：数组的长度-1
findVal：要查找的值
left + (right - left) x (findVal - arr[left]) / (arr[right] - arr[left])
比如现在有一个数组：int[] arr = {1,2,3,4,....,100};
那么假如我们要查询1的下标，那么按照插值查找的公式应当是：0 + (99 - 0) x (1 - 0) / (99 - 0) = 0
一下子就找到了
所以，插值算法最重要的就是它的自适应，在数字有序排列并且数据量十分多时，插值查找的优势巨大
代码实现
/**
* 插值算法
*
* @param arr 要去寻找的数组
* @param left 左边的索引
* @param right 右边的索引
* @param findVal 要查找的值
* @return
*/
public static int interpolationSearch(int[] arr, int left, int right, int findVal) {
/*
假如左边的指针比右边的指针大，那么说明没有找到最终的值，返回-1即可
*/
if (left > right) {
return -1;
}
/*
假如还在寻找的过程中，那么有如下三种情况：
*/
//中间索引a
int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
//中间值
int midVal = arr[mid];
//1、假如要查找的值>中间值，那么进行向右递归
if (findVal > midVal) {
return binarySeach(arr, mid + 1, right, findVal);
}
//2、假如要查找的治<中间值，那么进行向左递归
if (findVal < midVal) {
return binarySeach(arr, left, mid - 1, findVal);
}
//3、剩下的一种情况就说明已经找到了对应的值，结束递归，返回对应的索引
return mid;
}
基本上和二分查找差不多，唯一的区别就是mid的计算
斐波那契（黄金分割）查找
斐波那契查找概述
概念介绍
1、黄金分割点
把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比，取其三位数字的近似值为0.618，这个数值就是黄金分割点。
由于按此比例设计的造型十分美丽，因此成为黄金分割，也称为中外比。这是一个神奇的数字，会带来意想不到的效果。
2、斐波那契数列
斐波那契数列是这样的：{1,1,2,3,5,8,13,21,34,55}
其中除了前两位之外，后面的每一个值都是前面两个值相加得到的结果
斐波那契数列到了最后的数值，两个相邻相邻的数值的比值，其实就无限接近于黄金分割点0.618
3、在数学上，斐波那契被递归方法如下定义：F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2)（n>=2），......
斐波那契查找的原理
我们刚才讲到，在数学中的定义F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2)（n>=2）
但是我们知道，在Java中数组的下标是以0开始的，所以根据 F(k) = F(k-1) + F(k-2) 得到：
F(k)-1 = (F(k-1)-1) + (F(k-2)-1) + 1，这样所有的下标都减去了1，符合了程序的定义
其实mid在黄金分割段附近，但是注意，它的值不是F(k-1)-1，我们将它定义为low + F(k-1)-1
也就是说，mid = low + F(k-1)-1，其中low为最左端的值
但是现在有一个问题：假如我们的长度不够了怎么办？比如斐波那契需要长度为8的线段，然而我们只有7个或者更少，那么我们采取的解决措施是：使用最后一个的数值去填充到线段的后半部分，如下：
斐波那契查找举例
假如我们现在有一个数组：int[] arr = {1,2,3,4,5,6,7,8,9,10}，假如我们要查询9，下面的步骤应当是这样的：
1、因为数组长度为10，但是斐波那契数列中没有10这个数字，所以补充到13
2、阶段2，找到第一个mid节点，然后数值与9比较
3、因为数值比9小，那么向右递归，寻找第二个mid节点
4、同理，向左递归，直到找到最终数值
代码实现
/**
* 斐波那契数列的生成
*
* @param length 需要的斐波那契数列的长度
* @return 返回一个斐波那契数列
*/
public static int[] fibonacci(int length) {
int[] fibonacciArr = new int[length];
//斐波那契数列的前两位是1
fibonacciArr[0] = 1;
fibonacciArr[1] = 1;
//从第三位开始填充，直到填充到最后一位
for (int i = 2; i < fibonacciArr.length - 1; i++) {
fibonacciArr[i] = fibonacciArr[i - 1] + fibonacciArr[i - 2];
}
return fibonacciArr;
}
/**
* 斐波那契查找
*
* @param arr 要查询的数组
* @param fibonacci fibonacci 需要一个斐波那契数列，根据这个进行搜索
* @param val 要查询的值
* @return 返回的数组下标
*/
public static int fibonacciSearch(int[] arr, int[] fibonacci, int val) {
int low = 0;
int high = arr.length - 1;
//定义斐波那契数组的下标，暂定为0
int k = 0;
//表示mid节点
int mid = 0;
//因为我们的数组长度不一定符合斐波那契的规则，所以我们要获取能符合斐波那契规则的长度
while (arr.length > fibonacci[k]) {
k++;
}
//我们构造一个新的数组，让超出的部分的值为arr最后的值
int[] temp = Arrays.copyOf(arr, fibonacci[k]);
for (int i = arr.length; i < temp.length; i++) {
temp[i] = arr[high];
}
/*
使用while循环来处理数据
只要low<=high并且没有找到数据退出，就说明还有数据可以寻找
只要low>high，那么说明全部的数据都找完了，也没有找到对应的数据
*/
while (low <= high) {
//给mid赋值
mid = low + fibonacci[k - 1] - 1;
//假如val小于中间值，那么说明要寻找的数字在左边，那么向左寻找
if (val < temp[mid]) {
//令右边的界限到达mid的前一位，说明要从low-high去查找
high = mid - 1;
/*
我们之前说 F(k)-1 = (F(k-1)-1) + (F(k-2)-2) + 1
斐波那契数列是 1,1,2,3,5,8,13,...
现在界限改变了，长度从13改为了8，那么k肯定也需要改变一下了
比如以前F(13)对应的下标是6，那么现在换为了F(8)下标肯定是5了
*/
k--;
continue;
}
//假如val大于中间值，那么说明要寻找的数字在右边，那么向右寻找
if (val > temp[mid]) {
//左边的界限从刚才的界限到达了mid节点的下一位
low = mid + 1;
/*
k = k - 2其实也是一眼的，还是按照上面的13拆分开始讲
13拆分为8和5，左边是8，右边肯定就是5，那么就是k-2了
*/
k -= 2;
continue;
}
//假如val等于中间值，那么就说明要寻找的数字找到了，那么返回下标即可
if (val == temp[mid]) {
/*
但是不要着急，因为数组是经过补长的
因为我们的high就是数组的长度，所以可以根据high来判断mid是否超过了原数组的下标
假如mid超过了原数组的下标，那么因为mid下标的值等于high下标的值，直接返回high即可
假如mid没有超过原数组的下标，那么直接返回mid即可
*/
return mid < high ? mid : high;
}
}
//假如一次while循环全都找不到，那么说明这个数值根本不存在
return -1;
}
斐波那契查找的前提是，一个数组应该是一个有序数组