顺二差查找（顺序、二分、插值查找）
1.查找算法概述
查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算，例如编译程序中符号表的查找。
本文简单概括性的介绍了常见的七种查找算法，说是七种，其实*二分查找*、*插值查找*以及*斐波那契查找*都可以归为一类
——插值查找。插值查找和斐波那契查找是在二分查找的基础上的优化查找算法。
（1）查找定义
根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）。
（2）查找算法分类
1）静态查找和动态查找
注：静态或者动态都是针对查找表而言的。动态表指查找表中有删除和插入操作的表。
2）无序查找和有序查找
无序查找：被查找数列有序无序均可；
有序查找：被查找数列必须为有序数列。
（3）查找算法分析
平均查找长度（Average Search Length，ASL）：需和指定key进行比较的关键字的个数的期望值，
称为查找算法在查找成功时的平均查找长度。
对于含有n个数据元素的查找表，查找成功的平均查找长度为：ASL = Pi*Ci的和。
Pi：查找表中第i个数据元素的概率。
Ci：找到第i个数据元素时已经比较过的次数。
2.顺序查找
（1）方法说明
顺序查找适合于存储结构为顺序存储或链接存储的线性表。
（2）基本思想
顺序查找也称为线形查找，属于无序查找算法。从数据结构线形表的一端开始，顺序扫描，
依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，
表示查找失败。
（3）复杂度分析
查找成功时的平均查找长度为：（假设每个数据元素的概率相等） ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;当查找不成功时，需要n+1次 比较，时间复杂度为O(n);所以，顺序查找的时间复杂度为O(n)。
代码实现
//顺序查找
public static int seqSearch(int[] arr, int index) {
int temp = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == index) {
temp = i;
break;
}
}
return temp;
}
3.二分查找
概念：
是一种在**有序数组**中查找某一特定元素的搜索算法。
思路：
搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过 程结束；
如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。
如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。
代码实现:
/**
* 二分查找
*
* @param index
* @return 返回一个集合
*/
public static ArrayList<Integer> BinarySearch(int[] arr, int index, int left, int right) {
if (left > right) return null;
ArrayList<Integer> list = new ArrayList<Integer>();
int mid = (left + right) / 2;
int midVal = arr[mid];
if (midVal > index) return BinarySearch(arr, index, left, mid - 1);
else if (midVal < index) return BinarySearch(arr, index, mid + 1, right);
else {
//往左边扫描，如果有相同值，则继续加入集合
// while (mid > left && arr[mid - 1] == index) if (arr[--mid] == index) list.add(mid);
// while (mid < right && arr[mid + 1] == index) if (arr[++mid] == index) list.add(mid);
//想着左边扫秒
int temp = mid - 1;
while (true) {
if (temp < 0 || arr[temp] != index) break;
list.add(temp);
temp--;
}
list.add(mid);
//右边扫描
temp = mid + 1;
while (true) {
if (temp > right || arr[temp] != index) break;
list.add(temp);
temp++;
}
return list;
}
}
斐波拉契查找算法：
条件：
(1)数据必须采用顺序存储结构；(2)数据必须有序。
原理：
(1)最接近查找长度的斐波那契值来确定拆分点;(2)黄金分割。
时间复杂度：
与拆半查找一样，也是logn。有博客说，在处理海量数据时，拆分查找的middle = (low + hight)/2，除法可能会影响效率，而斐波那契的middle = low + F[k-1] -1，纯加减计算，速度要快一些。我觉得是扯淡，那咋不用middle = (loe+hight)>>2来代替，要知道相比于加减乘除而言，位运算的效率可是最高的哟。嘻嘻
代码：
```java
/**
* 斐波拉契查找
*
* @param arr
* @param index
* @param left
* @param right
* @return
*/
public static int FibonacciSearch(int[] arr, int index, int left, int right) {
int[] f = fib(20);
int n = 0;
int low = 0;
int high = arr.length - 1;
int mid = 0;
while (f[n] - 1 < high) n++;
//对数组索引进行托管
//如果索引对不上，则对数组进行扩容
int[] temp = new int[f[n]];
for (int i = 0; i < arr.length; i++) temp[i] = arr[i];
for (int i = high + 1; i < temp.length; i++) temp[i] = arr[high];
//进行查找
while (low <= high) {
mid = low + f[n - 1] - 1;
if (temp[mid] < index) {
low = mid + 1;
n -= 2;
} else if (temp[mid] > index) {
n--;
high = mid - 1;
} else {
if (mid > high) return high;
return mid;
}
}
return -1;
}
#### 插值算法：
```java
/**
* 插值查找
*
* @param index
* @return
*/
public static int InsertValSearch(int[] arr, int index, int left, int right) {
if (left > right || arr[0] > index || index > arr[arr.length - 1]) {
return -1;
}
int mid = left + (right - left) * (index - arr[left]) / (arr[right] - arr[left]);
if (arr[mid] > index) InsertValSearch(arr, index, left, mid - 1);
else if (arr[mid] < index) InsertValSearch(arr, index, mid + 1, right);
else return mid;
return -1;
}
浙公网安备 33010602011771号