查找算法
- 线性查找
- 二分查找/折半查找
- 插值查找
- 斐波那契查找
1. 线性查找
哈哈哈，好笨，但却是我经常写的查找算法没错了
public class SeqSearch {
public static void main(String[] args) {
int[] arr = {1,9,11,-1,34,89};
int index = seqSearch(arr,34);
System.out.println(index==-1?"未找到":"找到了元素下标为=="+index);
}
private static int seqSearch(int[] arr, int value) {
for (int i = 0; i < arr.length; i++) {
if (arr[i]==value){
return i;
}
}
return -1;
}
}
2. 二分查找
- 须是一个有序数组
- 如果是无序数组，需要先排序
思路分析
- 首先确定该数组的中间值的下标，mid = （left+right）/2
- 然后让要查找的数findVal 和 arr[mid]比较
- 如果findVal>arr[mid],说明要查找的数在mid的右边，因此需要向右递归查找
- 如果findVal<arr[mid],说明要查找的数在mid的左边，因此需要向左递归查找
- 如果findVal == arr[mid] ,就返回
- 什么时候结束递归
- 找到就结束递归
- 递归完整个数组，依然没有找到findVal，也需要结束递归，当left>right就需要退出
代码实现
简单实现
/**
* @author DSH
* @date 2020/5/7
* @description 二分查找
*/
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1,8,10,89,1000,1234};
int index = binarySearch(arr,89,0,arr.length-1);
System.out.println("找到了，下标为=="+index);
int[] arr2 = {1,8,10,89,1000,1000,1000,1234};
ArrayList<Integer> resList = binarySearch2(arr2, 1000, 0, arr2.length - 1);
System.out.println("找到了，结果集为=="+resList);
}
//二分查找算法
private static int binarySearch(int[] arr, int findVal, int left, int right) {
//当left>right时，说明递归整个数组，但是没有找到
if (left>right){
return -1;
}
int mid = (left + right) / 2;
if (findVal > arr[mid]) {
return binarySearch(arr, findVal, mid+1, right);
}else if (findVal < arr[mid]) {
return binarySearch(arr, findVal, left, mid-1);
}else {
return mid;
}
}
}
代码完善
当一个有序数组中，有多个相同的数值时，如果将所有数值都查到，如{1,8,10,89,1000,1000,1234}
思路分析
- 在找到mid值时，不马上返回
- 向mid索引值的左边扫描，将所有满足查找值的元素的下标加入到集合中
- 向mid索引值的右边扫描，将所有满足查找值的元素的下标加入到集合中
- 将集合返回
//返回所有要查找的值
private static ArrayList<Integer> binarySearch2(int[] arr, int findVal, int left, int right) {
if (left>right){
return new ArrayList<>();
}
int mid = (left + right) / 2;
if (findVal > arr[mid]) {
return binarySearch2(arr, findVal, mid+1, right);
}else if (findVal < arr[mid]) {
return binarySearch2(arr, findVal, left, mid-1);
}else {
//思路
//1 在找到mid值时，不马上返回
//2 向mid索引值的左边扫描，将所有满足查找值的元素的下标加入到集合中
//3 向mid索引值的右边扫描，将所有满足查找值的元素的下标加入到集合中
//4 将集合返回
ArrayList<Integer> resIndexList = new ArrayList<>();
//向左扫描
int temp = mid-1;
while (true){
if (temp<0||arr[temp]!=findVal){//退出
break;
}
//否则将temp放入集合中
resIndexList.add(temp);
temp--;
}
resIndexList.add(mid);
temp = mid+1;
while (true){
if (temp>arr.length-1||arr[temp]!=findVal){//扫描到最右边了
break;
}
//否则将temp放入集合中
resIndexList.add(temp);
temp++;
}
return resIndexList;
}
}
3. 插值查找
- 插值查找类似于二分查找，不同的是插值查找每次从自适应mid处开始查找
- 将折半查找中的求mid索引的公式，low表示左边索引，high表示右边索引，key表示要查找的值
- mid = （low+high）/2 = low+ 1/2*(high-low) 改成 mid = low+（key-a[low])/(a[high]-a[low])*(high-low)
- int midIndex = low +（high-low）*（key-a[low])/(a[high]-a[low]); 插值索引
如查找1-100的连续数组 找1
二分查找，需要多次递归才能找到
插值查找 int mid = 0+99*0/99 = 0，一次就找到了
==对于数据量较大，关键字分布比较均匀的查找表来说，采用差值查找，速度较快；
关键字分布不均匀的情况下，插值查找不一定比折半查找要好==
代码实现
/**
* @author DSH
* @date 2020/5/8
* @description 插值查找
*/
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,38);
System.out.println("找到了，下标为=="+index);
}
//插值查找要求数组是有序的
private static int insertValueSearch(int[] arr, int low, int high, int findVal) {
System.out.println("查找中");
//findVal<arr[0]和findVal>arr[arr.length-1]必须需要
//否则得到的mid可能越界
if (low>high||findVal<arr[0]||findVal>arr[arr.length-1]){
return -1;
}
//求出mid，自适应
int mid = low + (high-low)*(findVal-arr[low])/(arr[high]-arr[low]);
int midVal = arr[mid];
if (midVal<findVal){//向右查找
return insertValueSearch(arr,mid+1,high,findVal);
}else if (midVal>findVal){//向左查找
return insertValueSearch(arr,low,mid-1,findVal);
}else {//找到了
return mid;
}
}
}
4. 斐波那契（黄金分割法）查找
斐波那契数列{1,1,2,3,5,8,13,21,34,55}发现斐波那契数列的两个相邻数的比例，无限接近黄金分割值0.618.
思路分析
斐波那契查找原理与二分查找和插值查找相似，仅仅改变了中间节点mid的位置，mid不再是中间或者插值得到，而是位于黄金分割点附近，即mid = low+F(k-1)-1,(F代表斐波那契数列)，
对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的两段
- 类似的，每一子段也可以用相同的方式分割
- 但顺序表长度n不一定刚好等于F[k]-1，所以需要将原来的顺序表长度n增加至F[k]-1。这里的k值只要能使得F[k]-1恰好大于或等于n即可，由以下代码得到，顺序表长度增加后，新增的位置（从n+1到F[k]-1位置），都赋为n位置的值即可。
代码实现
/**
* @author DSH
* @date 2020/5/8
* @description 斐波那契（黄金分割查找）
*/
public class FibonacciSearch {
public static int maxSize = 20;
public static void main(String[] args) {
int [] arr = {1,8,10,89,1000,1234};
int[] f = fib();
System.out.println("斐波那契=="+Arrays.toString(f));
int index=fibSearch(arr,89);
System.out.println("找到了，下标为=="+index);
// //递归生成斐波那契
// int [] arr2 = new int[maxSize];
// for (int i = 0; i < maxSize; i++) {
// arr2[i] = fib2(i);
// }
// System.out.println("斐波那契=="+Arrays.toString(arr2));
}
//用非递归得到一个斐波那契数列
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 key){
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]);
//实际上需求使用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] = arr[high];
}
//使用while循环处理，找到key
while (low<=high){
mid = low + f[k-1]-1;
if (key<temp[mid]){//继续向数组的左边查找
high = mid - 1;
//为什么要k--
//1 全部元素 = 前面的元素+后面的元素
//2 f[k] = f[k-1]+f[k-2]
//3 因为前面有f[k-1]个元素，所以可以继续拆分 f[k-1] = f[k-2]+f[k-3]
//4 即在f[k-1]的前面继续查找k--
//5 即下次循环mid = f[k-1-1]-1;
k--;
}else if (key>temp[mid]){//继续向数组的右边查找
low = mid+1;
//为什么是k -= 2
//1 全部元素 = 前面的元素+后面的元素
//2 f[k] = f[k-1]+f[k-2]
//3 因为后面有f[k-2] 所以继续拆分 f[k-1] = f[k-3]+f[k-4]
//4 即在f[k-2]的前面进行查找 k -= 2
//5 即下次循环mid = f[k-1-2]-1
k -= 2;
}else {//找到
if (mid<=high){
return mid;
}else {
return high;
}
}
}
return -1;
}
//递归生成斐波那契数列
public static int fib2(int n){
if (n < 2) {
return 1;
}
return fib2(n - 1) + fib2(n - 2);
}
}
