什么是查找算法？
查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算。查找算法是用关键字标识一个数据元素，查找时根据给定的某个值，在表中确定一个关键字的值等于给定值的记录或数据元素。在计算机中进行查找的方法是根据表中的记录的组织结构确定的。
在java中，我们常用的查找有四种：顺序查找（线性查找）、二分查找、插值查找、斐波那契查找。接下来我们就详细了解一下这四种查找算法。
1、顺序查找
顺序查找也称为线形查找，被查找的数据需要有序才可以进行。顺序查找从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。
1.1 最简单的顺序查找代码：这种查找方法我们发现他不可以查找到数列中重复的数，查找到一个就会返回，不会继续向下查找。测试我们也可以发现这个问题。
public class SeqSearch{
public static void main(String[] args) {
int[] arr = {1, 6, 3, 6, 8, 2};
int index = seqSearch(arr, 6);
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;
}
}1.2 为了解决上面无法查找数列中重复值的问题，我们将顺序查找的代码进行改进：我们查找到第一个需要查找到值时，不立刻返回，继续让程序继续向后查找，最后将所有结果存储到集合再返回，就可以解决上述问题。
public class test {
public static void main(String[] args) {
int[] arr = {1, 6, 3, 6, 8, 2};
List<String> index = seqSearch1(arr, 6);
System.out.println("查找到数据，下标为" + index);
}
public static List<String> seqSearch1(int[] arr, int value) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < arr.length; i++) {
if (arr[i] == value) {
list.add(Integer.toString(i));
}
}
return list;
}
}
2、二分查找
二分查找要求线形表中的结点按关键字值升序或降序排列，首先用给目标数值（需要查找的值）与中间位置的数字进行比较，中间位置的数把线形表分成两个子表，若相等则查找成功；若不相等，再根据目标数值与该中间位置数的比较结果确定下一步查找哪个子表，如果目标数值大于中间数值就像右继续递归查找，反之就像左边递归查找，这样递归进行，直到查找到或查找结束发现表中没有这样的结点。
public class binarySearch {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 5, 5, 5};
List<Integer> resIndexList = binarySearch(arr, 0, arr.length - 1, 5);
System.out.println(resIndexList);
}
public static List<Integer> binarySearch(int[] arr, int left, int right, int findVal) {
//如果没有，不设置直接报错
if (left > right) {
return new ArrayList<Integer>();
}
int mid = (left + right) / 2;
int minVal = arr[mid];
if (findVal > minVal) {
return binarySearch2(arr, mid + 1, right, findVal);
} else if (findVal < minVal) {
return binarySearch2(arr, left, mid - 1, findVal);
} else {
/**
* 思路分析：
* 再找到mid索引值，不要马上返回
* 向mid值的左边扫描，将所有满足的值都查到，加入到集合中
* 向mid值的右边扫描，将所有满足的值都查到，加入到集合中
* 将集合值返回
*/
List<Integer> resIndexList = new ArrayList<Integer>();
//向左边扫描
int temp = mid - 1;
while (true) {
if (temp < 0 || arr[temp] != findVal) {
break;
}
//否则就放到集合中
resIndexList.add(temp);
temp -= 1;
}
resIndexList.add(mid);//把mid也加进行
//向右扫描
temp = mid + 1;
while (true) {
if (temp > arr.length - 1 || arr[temp] != findVal) {
break;
}
resIndexList.add(temp);
temp += 1;
}
return resIndexList;
}
}
}
3、插值查找
插值查找算法类似于二分查找，是二分查找的优化。不同的是插值查找的mid是每次从自适应mid处开始查找。(left right为数列的左右下标，findVal为需要查找的数)，这样查找出来的中间值更加接近findVal，提高了效率。
二分查找：mid = left + 1/2 （left - right）
插值查找：mid = left + （findVal - a[left]）/（a[right] - a[left]）*（left - right）
注意：
（1）对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找, 速度较快.
public class InsertValueSearch {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int index = insertValueSearch(arr, 0, arr.length - 1, 1);
System.out.println(index);
}
//插值排序算法
public static int insertValueSearch(int[] arr, int left, int right, int findVal) {
//否则我们得到的mid会越界，这样做可以提升效率
if (left > right || findVal > arr[right] || findVal < arr[left]) {
return -1;
}
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;
}
}
}4、斐波那契查找（黄金分割法）
这里需要先介绍几个概念帮助大家理解：
（1）黄金分割点：
黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。
（2）斐波那契数列：
斐波那契数列类似于{1, 1, 2, 3, 5, 8, 13, 21, 34, 55.....} ，波那契被递归方法如下定义：F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2) （n>=2）。1)斐波那契数列的两个相邻数 的比例，无限接近 黄金分割值0.618。
（3）斐波那契查找：
斐波那契查找原理与前两种相似，仅仅改变了中间结点（mid）的位置，mid不再是中间或插值得到，而是位于黄金分割点附近，即mid=low+F(k-1)-1（F代表斐波那契数列）。如果我们使用这个mid值进行查找，不能保证被查找的数列长度等于f[K]的值，就需要将数列进行补全，缺多少位就补将数列最后一个补到缺的位置，例如：{1,8,20,89,99,123,123,123,123...}
（4）对F(k-1)-1的理解：
由斐波那契数列 F[k]=F[k-1]+F[k-2] 的性质，可以得到 （F[k]-1）=（F[k-1]-1）+（F[k-2]-1）+1 。该式说明：只要顺序表的长度为F[k]-1，则可以将该表分成长度为F[k-1]-1和F[k-2]-1的两段。从而中间位置为mid=low+F(k-1)-1。
public class FibonacciSearch {
public static int maxSize = 20;
public static void main(String[] args) {
int[] arr = {1, 8, 10, 89, 1000, 1234};
int index = fibSearch(arr, 1234);
System.out.println(index);
}
//后面所用到的mid为 mid = low+F(k-1)-1,需要用到斐波那契数列，因此我们先构造一个
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;
}
//斐波那契查找算法（非递归方法）
public static int fibSearch(int[] arr, int findVal) {
int low = 0;
int high = arr.length - 1;
int k = 0;//表示斐波那契分割数值的下标
int mid = 0;//存放mid值
int[] f = fib();//获取斐波那契数列
//获取斐波那契分割数值的下标
while (high > f[k] - 1) {
k++;
}
//因为f[k]的值可能会大于arr的长度，因此需要用Arrays类构造一个新数组，指向arr
//不足部分会使用0填充
int[] temp = Arrays.copyOf(arr, f[k]);
//{1,8,10,89,1000,1234}======={1,8,10,89,1000,1234,1234,1234,1234...}
for (int i = high + 1; i < temp.length; i++) {
temp[i] = arr[high];
}
//使用while循环来处理，找到我们需要的findVal
while (low <= high) {//只要满足条件就可以开始找
mid = low + f[k - 1] - 1;
if (findVal < temp[mid]) {
high = mid - 1;
k--;
} else if (findVal > temp[mid]) {
low = mid + 1;
k -= 2;
} else {
//需要确定，返回的是哪个下标
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
}
