6. 查找算法
在java中我们常用的查找算法是:
- 顺序(线性)查找
- 二分查找/折半查找
- 插值查找
- 斐波那契查找
6.1 线性查找
代码实现
public class SeqSearch {
public static void main(String[] args) {
int[] arr = {1,9,11,-1,34,80};
int index = seqSearch(arr,11);
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
6.2 二分查找
只针对有序数列查找
思路分析
-
首先确定该数组的中间的下标:mid=(left+right)/2
-
然后让需要查找的数findval和arr[mid]进行比较
2.1 findval > arr[mid],说明你需要查找的数在mid的右边,因此需要递归的向右查找
2.2 findval < arr[mid],说明你需要查找的数在mid的左边,因此需要递归的向左查找
2.3 find == arr[mid],说明找到,直接返回
-
什么时候结束递归呢
3.1 找到就结束递归
3.2 递归完整个数组,仍然没有找到findval,也需要结束递归当left > right就需要退出。
6.2.1 二分查找的基本版
对于要查找的数据没有出现重复的现象
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,1234);
System.out.println("resIndex="+resIndex);
}
//二分查找算法
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 > midVal){
//向右递归
return binarySearch(arr,mid+1,right, findVal);
} else if (findVal < midVal){
return binarySearch(arr,left,mid-1,findVal);
} else {
return mid;
}
}
}
结果
resIndex=5
6.2.2 二分查找的高级版
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1, 8, 10, 89, 1000, 1000, 1000, 1234};
List<Integer> resIndex = binarySearch2(arr, 0, arr.length - 1, 1000);
System.out.println("resIndex=" + resIndex);
}
//二分查找算法
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 > midVal) {
//向右递归
return binarySearch(arr, mid + 1, right, findVal);
} else if (findVal < midVal) {
return binarySearch(arr, left, mid - 1, findVal);
} else {
return mid;
}
}
//将表中所有需要查找的数都找出来
//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 new ArrayList<Integer>();
}
int mid = (left + right) / 2;
int midVal = arr[mid];
if (findVal > midVal) {
//向右递归
return binarySearch2(arr, mid + 1, right, findVal);
} else if (findVal < midVal) {
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放入到resIndexList
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;
}
//否则,将temp放入到resIndexList
resIndexlist.add(temp);
temp += 1;
}
return resIndexlist;
}
}
}
结果
resIndex=[4, 5, 6]
6.3 插值查找
6.3.1 插值查找的基本原理
插值查找算法类似于二分查找,不同的是插值查找每次从自适应mid开始查找
关于mid的定义如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NllThBHL-1618541531991)(C:\Users\dongwei\AppData\Roaming\Typora\typora-user-images\image-20210331082304226.png)]
插值查找算法的举例说明
数组arr = [1,2,3,…,100]
假如我们要查找的是1
使用二分查找的话需要多此递归,才能找到1
使用插值查找算法
int mid = left + (left - right)*(findVal - arr[left])/(arr[right] - arr[left])
int mid = 0 + (99 - 0)*(1 - 1)/(100 - 1) = 0
同理我们如果找的是100则
int mid = 0 + (99 - 0)*(100 - 1)/(100 - 1) = 99
6.3.2 插值查找的代码实现
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 = insertVlaueSearch(arr, 0, arr.length - 1, 10);
System.out.println("index = " + index);
}
//编写插值算法的
//说明:插值查找算法,也是要求数组是有序的
public static int insertVlaueSearch(int[] arr, int left, int right, int findVal) {
System.out.println("~~~~~~~~");
if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
return -1;
}
int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
int midVal = arr[mid];
if (findVal > midVal) {
//说明数组应该向左查询
return insertVlaueSearch(arr, mid + 1, right, findVal);
} else if (findVal < midVal) {
return insertVlaueSearch(arr, left, mid - 1, findVal);
} else {
return mid;
}
}
}
结果
~~~~~~~~
index = 9
插值查找的注意事项
- 对于数据量较大,关键字分布比较均匀的查找表来说,采用插值查找,速度比较快
- 关键字分布不均匀的情况下,该方法不一定比折半查找的效果好。
6.4 斐波那契(黄金分割)查找算法
6.4.1 斐波那契查找的基本介绍
- 黄金分割点是指把一条线段分割成两部分,使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是0.618。由于按此比例设计的造型十分美丽,因此称为黄金分割,也称中外比。这是一个神奇的数字,会带来意想不到的效果。
- 斐波那契数列{1,1,2,3,5,8,13,21,34,55}发现斐波那契数列的两个相邻数的比例,无限接近黄金分割值0.618。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SV9ttCaJ-1618541531995)(C:\Users\dongwei\AppData\Roaming\Typora\typora-user-images\image-20210331091714277.png)]
6.4.2 代码实现
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));
}
//因为我们后面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[] a, int key) {
int low = 0;
int high = a.length - 1;
int k = 0; //表示斐波那契分割数值的下标
int mid = 0; //存放mid值
int f[] = fib(); //获取到斐波那契数列
//获取到斐波那契分割数值的下标
while (high > f[k] - 1) {
k++;
}
//因为f[k]值可能大于a的长度,因此我们需要使用Arrays类,构造一个新的数组,并指向a[]
//不足的部分使用0进行填充
int[] temp = Arrays.copyOf(a, f[k]);
//上面这一部分是将值进行0填补,但是我们希望的是将填补的数值转换为该数组的最高值
for (int i = high + 1; i < temp.length; i++) {
temp[i] = a[high];
}
//使用while循环处理,找到我们的数hey
while (low <= high) {
mid = low + f[k - 1] - 1;
//只要满足这个条件,就可以开始找
if (key < temp[mid]) {
//此时我们应该继续向前找(左边)
high = mid - 1;
k--;
/*
* 说明一下为什么是k--
* 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--
* */
} else if (key > temp[mid]) {
low = mid + 1;
k -= 2;
//因为后面我们有f[k-2] 所以可以继续拆分为f[k-1] = f[k-3] + f[k-4]
} else {
//找到了
//需要确定我们需要返回的是哪个值
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
}
index=5
6.4.3 难点理解
为什么后面需要k-2
mid的取值要求的是黄金分割点,意思就是说要保证mid之前的数字比例和mid之后的数字比例是0.618,我们是为了方便才设定了一个斐波那契数列,就是说这个数列已经将如何取值数组值得小标进行了规范,我们也可以自己去计算,但是直接从数组取值会更加的方便。
我们现在查找的数字排序如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h9uNt1xh-1618541531998)(C:\Users\dongwei\AppData\Roaming\Typora\typora-user-images\image-20210331141610229.png)]
按照第一步执行的我们找到了mid值为4
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N90JJREf-1618541532002)(C:\Users\dongwei\AppData\Roaming\Typora\typora-user-images\image-20210331142109251.png)]
但是此时我们需要往前走,这个时候会发现此时数据被分成两部分,
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S1CPauyd-1618541555219)(C:\Users\dongwei\AppData\Roaming\Typora\typora-user-images\image-20210331142413032.png)]
此时我们拿出斐波那契数列按照之前的八个数据,我们得到的数列是:1,1,2,3,5,8
此时第一部分对应的是 5 ,第二部分对应的是 3 。这样我们在进入第二部分判定的时候,需要找出中值就是2。因为2/3才能保证是黄金分割点。其实就是往前面移动一位。