顺序(线性)查找
直接遍历就是了
public static int seqSearch(int[] arr, int value) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == value) {
return i;
}
}
return -1;
}
二分查找/折半查找
package search;
import java.util.ArrayList;
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,11);
// System.out.println(resIndex);
ArrayList<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1000);
System.out.println(resIndexList);
}
// 二分查找算法
/**
*
* @param arr 数组
* @param left 左边的索引
* @param right 右边的索引
* @param findVal 要查找的值
* @return 找到就返回 -1
*/
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;
}
}
// 完成一个课后思考题
/*
找到所有相同的值
*/
public static ArrayList<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {
// 当left > right 说明递归整个数组都没找到(退出条件1)
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 {
//退出条件2
ArrayList<Integer> resIndexList = new ArrayList<>();
// 向左遍历
int temp = mid - 1;
while(true) {
if (temp < 0 || arr[temp] != findVal) { //退出
break;
}
// 否则temp放入到集合中
resIndexList.add(temp);
temp -= 1; //temp左移
}
resIndexList.add(mid);
// 向右遍历
temp = mid +1;
while(true) {
if (temp > arr.length-1 || arr[temp] != findVal) { //退出
break;
}
// 否则temp放入到集合中
resIndexList.add(temp);
temp += 1; //temp右移
}
return resIndexList;
}
}
}
二分查找的思路分析
- 首先确定该数组的中间的下标
mid = (left + right) / 2- 然后让需要查找的数 findVal 和 arr[mid] 比较
- 1 findVal > arr[mid] , 说明你要查找的数在mid 的右边, 因此需要递归的向右查找
2.2 findVal < arr[mid], 说明你要查找的数在mid 的左边, 因此需要递归的向左查找
2.3 findVal == arr[mid] 说明找到，就返回
- 什么时候我们需要结束递归.
- 找到就结束递归
- 递归完整个数组，仍然没有找到findVal ，也需要结束递归 当 left > right 就需要退出
当然，如果有很多相同的元素，由于我们查找的是一个有序的数组，我们可以通过查找 我们所寻找到的第一个元素并遍历它 左 和 右侧的元素是否与之相同，相同就存入集合，不相同就结束遍历！
插值查找
我们在使用二分查找的时候，会有一个问题：为什么一定是要二分，不能是四分、八分吗？
而且，打个比方，如果我们要在字典中查找zoo这个单词，我们一般的做法都会是直接翻到字典的最后面，而不是从中间翻开。而插值查找则与此类似，它是一种有目的的查找
- 在二分查找中，mid = (low+high)/2，我们可以对这个公式做个变形，得到mid = (low+high+low-low)/2 = (2low + high-low)/2 = low + 1/2*(high-low)，而插值查找，要优化的就是这个1/2
- 插值查找中的计算方案，是使得mid = low + k(high-low)，k的计算方式为(key-a[low])/(a[high]-a[low])
如此一来，我们进行查找的时候，就会根据数据的分布情况来计算出更适宜的定位目标。虽然插值查找的时间复杂度也是O(logn)，但是 对于表长较长，关键字分布比较均匀的表而言，插值查找算法的性能要好得多。
添加链接描述
所以我们要把mid改为
可以理解为
对应上面的代码就是: 把1/2 换成他们的斜率，让数值更大概率地接近它的下标
int mid = left + (right – left) * (findVal – arr[left]) / (arr[right] – arr[left])
代码实现
// findVal<arr[0] || findVal>arr[arr.length-1] 必须需要
// 否则 mid 可能越界
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 insertValueSearch(arr,mid +1,right,findVal);
}else if (findVal < midVal) {
return insertValueSearch(arr,left,mid-1,findVal);
} else {
return mid;
}
注意:
- 对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找, 速度较快.
- 关键字分布不均匀的情况下，该方法不一定比折半查找要好
斐波那契查找
斐波那契(黄金分割法)原理
斐波那契查找原理与前两种相似，仅仅改变了中间结点（mid）的位置，mid不再是中间或插值得到，而是位于黄金分割点附近，即mid=low+F(k-1)-1
原理图
开始将k值与第F(k-1）位置的记录进行比较(及mid=low+F(k-1)-1),比较结果也分为三种
-
相等，mid位置的元素即为所求
-
如果 > ,low=mid+1,k-=2;说明:low=mid+1说明待查找的元素在[mid+1,hign]范围内，k-=2 说明范围[mid+1,high]内的元素个数为n-（F(k-1))= Fk-1-F(k-1)=Fk-F(k-1)-1=F(k-2)-1个，所以可以递归的应用斐波那契查找
-
如果 < ,high=mid-1,k-=1;说明:low=mid+1说明待查找的元素在[low,mid-1]范围内，k-=1 说明范围[low,mid-1]内的元素个数为F(k-1)-1个，所以可以递归的应用斐波那契查找
代码实现
package 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(fibSearch(arr,89));
}
// 先得到一个斐波那契数列
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; // 定义一个mid值
int f[] = fib(); // 获取到斐波那契数列
// 获取到斐波那契分隔数值的下标
while(high > f[k] -1) { // 当满足这个条件的时候，证明已经找到了
k++;
}
// 因为 f[k] 值，可能大于数组的长度 因此我们需要使用Arrays类，构造一个新的数组，并指向a
// 不足的部分会使用 0 填充
int[] temp = Arrays.copyOf(a,f[k]-1);
// 实际上需要使用 a数组的最后的数填充temp
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;
// 说明
// 1. 全部元素 = 前面的元素 + 后边的元素
// 2. f[k] = f[k-1] + f[k-2]
// 因为前面有 f[k-1] 个元素，所以我们继续拆分 f[k-1] = f[k-2] + f[k-3]
k--;
} else if (key > temp[mid]) { // 说明我们应该继续向数组的右边查找
low = mid +1;
// 为什么是k-2
// 因为 f[k] = f[k-1] + f[k-2]
// 因为后面有 f[k-2] 个元素， 可以继续拆分 f[k-1] = f[k-3] + f[k-4]
k -=2;
} else { // 找到了
// 需要确定，返回的是哪个下标
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
}
4664
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
