文章目录
前言
跟着B站的尚硅谷学习数据结构与算法，语言为java，目前是第十个代码内容——查找
课程传送门：尚硅谷——查找
一、查找算法介绍
在Java中，我们常用的查找方式有四种：
1）顺序（线性）查找
2）二分查找 / 折半查找
3）插值查找
4）斐波那契查找
二、线性查找
有一个数列 {1, 9, 11, -1, 34, 89}，判断数列中是否包含此名称
1.思路分析
线性查找不需要是有序列表也可以。如果找到了，就提示找到了，并给出下标值。
2.代码实现
package com.search;
public class SeqSearch {
public static void main(String[] args) {
int arr[] = {1, 9, 11, -1, 34, 89};
int index = seqSearch(arr, 11);
if (index == -1){
System.out.println("没有找到");
}else {
System.out.println("找到，下标为 = " + index);
}
}
/**
* 线性查找是找到一个满足条件的值就返回
* @param arr
* @param value
* @return
*/
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，8，10，89，1000，1234}，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示 “ 没有这个数 ”。
1.思路分析
1）首先确定该数组的中间的下标 mid = (left + right) / 2
2）然后让需要查找的数 findVal 和 arr[ mid ] 比较
- findVal > arr[ mid ]，说明你查找的数在 mid 的右边，因此需要递归的向右查找
- findVal < arr[ mid ]，说明你查找的数在 mid 的左边，因此需要递归的向左查找
- findVal == arr[ mid ]，说明找到了，就返回
什么时候结束递归
1）找到就结束递归
2）递归完整个数组，仍然没有找到 findVal，也需要结束递归，当 left > right 就需要退出
2.代码实现
package com.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,1234);
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){
int mid = (left + right) / 2;
int midVal = arr[mid];
if (left > right){
return -1;
}
if (findVal > midVal){
return binarySearch(arr,mid + 1, right,findVal);
}else if (findVal < midVal) {
return binarySearch(arr, left, mid,findVal);
}else {
return mid;
}
}
}
课后作业
有序数组 {1, 8, 10, 89, 1000, 1000, 1000, 1000,1234}中，有多个相同的数值，如何将所有的数值都查找到？
package com.search;
import java.util.ArrayList;
import java.util.List;
//注意使用二分查找的数组要有序
public class BinarySearch {
public static void main(String[] args) {
int arr[] = {1, 8, 10, 89, 1000, 1000, 1000, 1000,1234};
// int resIndex = binarySearch(arr,0,arr.length-1,1234);
// System.out.println("resIndex = " + resIndex);
List<Integer> resIndexList = binarySearch2(arr,0,arr.length-1,1000);
System.out.println("resIndexList = " + resIndexList);
}
/**
*
* @param arr 数组
* @param left 左边的索引
* @param right 右边的索引
* @param findVal 要查找的值
* @return 找到返回下标，找不到返回-1
*/
public static int binarySearch(int[] arr, int left, int right, int findVal){
int mid = (left + right) / 2;
int midVal = arr[mid];
if (left > right){
return -1;
}
if (findVal > midVal){
return binarySearch(arr,mid + 1, right,findVal);
}else if (findVal < midVal) {
return binarySearch(arr, left, mid,findVal);
}else {
return mid;
}
}
//数组的 {1, 8, 10, 89, 1000, 1000, 1000, 1000,1234}
//返回多个相同的数值
/*思路分析
* 1.在找到 mid 索引值，必要马上返回
* 2.向 mid 索引值的左边扫描，将所有满足1000的元素的下标，加入到集合ArrayList
* 3.向 mid 索引值的右边扫描，将所有满足1000的元素的下标，加入到集合ArrayList
* 4.将ArrayList返回
* */
public static ArrayList binarySearch2(int[] arr, int left, int right, int findVal){
int mid = (left + right) / 2;
int midVal = arr[mid];
if (left > right){
return new ArrayList<Integer>();
}
if (findVal > midVal){
return binarySearch2(arr,mid + 1, right,findVal);
}else if (findVal < midVal) {
return binarySearch2(arr, left, mid,findVal);
}else {
ArrayList<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);
temp = mid + 1;
while (true){
if (temp > arr.length - 1 || arr[temp] != findVal){
break;
}
resIndexlist.add(temp);
temp += 1;
}
return resIndexlist;
}
}
}
四、插值查找
1）插值查找算法类似于二分查找，不同的是插值查找每次从自适应 mid 处开始查找。
2）将折半查找中的求 mid 索引的公式，low 表示左边索引 left，high 表示右边索引 right。
3）int mid = low + (high + low) * (key - arr[ low ]) / (arr[ high ] - arr[ low ]) ； 插值索引
对应前面的代码公式：
int mid = left + (right + left) * (findVal - arr[ left ]) / (arr[ right ] - arr[ left ])
4）举例说明插值查找算法 1 - 100 的数组
1.思路分析
请对一个有序数组进行插值查找 {1，2，3，…，100}，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示 “ 没有这个数 ”。
2.代码实现
package com.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,50);
System.out.println("index = " + index);
}
/**
*
* @param arr 数组
* @param left 左边索引
* @param right 右边索引
* @param findVal 查找值
* @return
*/
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.注意事项
1）对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找，速度较快。
2）关键字分布不均匀的情况下，该方法不一定比折半查找要好。
五、斐波那契（黄金分割法）查找
1）黄金分割点是指把一条线段分割成两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是 0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这是一个神奇的数字，会带来意想不到的效果。
2）斐波那契数列 { 1，1，2，3，5，8，13，21，34，55} 发现斐波那契的两个相邻数的比例无限接近于黄金分割值 0.618。
1.基本原理
斐波那契查找原理与前两种相似，仅仅改变了中间节点（mid）的位置，mid 不再是中间或插值得到，而是位于黄金分割点附近，即 mid = low + F( k - 1 ) - 1
(F 代表斐波那契数列)，如下图：
对 F( k - 1 ) -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
2）类似的，每个子段也可以用相同的方式分割
3）但顺序表长度 n 不一定刚好等于 F[K-1]，所有需要将原来的顺序表长度 n 增加至 F[K] - 1。这里的 k 值只有能使得 F[K] - 1 恰好大于或等于 n 即可，有以下代码得到，顺序表长度增加后，新增的位置（从 n+1 到 F[K] - 1位置），都赋为 n 位置的值即可。
2.代码实现
请对一个有序数组进行斐波那契查找 {1，2，3，…，100}，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示 “ 没有这个数 ”。
package com.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,1));
}
//获取到斐波那契数列,后面需要 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;
}
//编写斐波那契查找法
/**
*
* @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; // 表示斐波那契分隔值的下标
int mid = 0;
int f[] = fib(); //获取的斐波那契数列
//获取斐波那契分隔值的下标
while (high > f[k] - 1){
k++;
}
//因为f[k] 的值可能大于 a 的长度，因此我们需要使用Arrays类，构造一个新的数组指向a[]
//不足的部分会使用0填充
int[] temp = Arrays.copyOf(a,f[k]);
//实际上需求使用a数组最后的数填充temp
//举例：
//temp = {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;
if (key < temp[mid]){
high = mid -1;
//要让f[k] = f[k-1] + f[k-2]变成f[k-1] = f[k-1-1] + f[k-2-1]
k--;
}else if (key > temp[mid]){
low = mid + 1;
//要让f[k] = f[k-1] + f[k-2]变成f[k-2] = f[k-1-2] + f[k-2-2]
k -= 2;
}else { //找到
if (mid <= high){
return mid;
} else{
return high;
}
}
}
return -1;
}
}
总结
以上就是本章要讲的内容，本文仅仅简单复述了老师讲课的文本内容，内容有误麻烦联系。
160
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
