线性查找
public class SeqSearch {
public static void main(String[] args) {
int[] arr = {1, 9, 11, -1, 34, 89};
int index = serSearch(arr, 11);
if (index == -1) {
System.out.println("没有找到该值");
} else {
System.out.println("找到,下标为: " + index);
}
}
/**
* 线性查找,找到一个满足条件的值就返回
*/
public static int serSearch(int[] arr, int value) {
// 线性查找是逐一对比,发现有相同的值,就返回下标
for (int i = 0; i < arr.length; i++) {
if (arr[i] == value) {
return i;
}
}
return -1;
}
}
二分查找
二分查找是一种查询效率非常高的查找算法。又称折半查找。
算法思想： 对有序的序列，每次都是以序列的中间位置的数来与待查找的关键字进行比较，每次缩小一半的查找范围，直到匹配成功。
注意: 使用二分查找的前提是数据是有序的。
查值索引的计算公式为： mid = (low + high) / 2
递归实现二分查找
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1, 8, 10, 89, 1000, 1234};
int index = binarySearch(arr, 0, arr.length - 1, 1234);
System.out.println("查找到的下标为: " + (index == -1 ? "没有找到该数据" : index));
}
/**
* 二分查找
*
* @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 class BinarySearchNoRecur {
public static void main(String[] args) {
int[] arr = {1, 3, 8, 10, 11, 67, 100};
int index = binarySearch(arr, 67);
System.out.println(index);
}
/**
* @param arr 待查找的数组, arr是升序排序
* @param target 要查找的数
*/
public static int binarySearch(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (arr[mid] == target) {
return mid;
} else if (arr[mid] > target) {
// 向左边查找
right = mid - 1;
} else {
// 向右边查找
left = mid + 1;
}
}
return -1;
}
}
插值查找
基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。插值查找也属于有序查找。
注： 对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。
插值索引的计算公式为： int mid = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low]);
代码示例：
public class InsertValueSearch {
public static void main(String[] args) {
int[] arr = new int[100];
for (int i = 0; i < arr.length; i++) {
arr[i] = i + 1;
}
System.out.println(Arrays.toString(arr));
insertValueSearch(arr, 0, arr.length - 1, 66);
}
/**
* 插值查找
*
* @param arr 数组
* @param left 左边索引
* @param right 右边索引
* @param findVal 要查找的值
* @return 找到返回下标, 没有找到返回-1
*/
public static int insertValueSearch(int[] arr, int left, int right, int findVal) {
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;
}
}
}
斐波那契(黄金分割法)查找
由于博主暂时没能理解透彻，就不误导大家了，感兴趣的话可以自己查找，示例代码如下：
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));
}
/**
* 因为后面 mid = low + F(k - 1) - 1,
* 需要使用到斐波那契数列,因此需要先获取到一个斐波那契数列
* 非递归方法得到一个斐波那契数列
*
* @return
*/
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;
// k表示斐波那契分割数值的下标
int k = 0;
// 存放mid值
int mid = 0;
// 获取到斐波那契数列
int f[] = fib();
// 获取到斐波那契分割数值的下标
while (high > f[k] - 1) {
k++;
}
// 因为 f[k] 值 可能大于 a 的长度,因此需要使用Arrays类,构造一个新的数组,并指向temp[]
// 不足的部分会使用0填充
int[] temp = Arrays.copyOf(a, f[k]);
// 需要使用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]
即在 f[k - 1] 的前面继续查找 k--
下次循环的时候, mid = f[k-1-1]-1
*/
k--;
} else if (key > temp[mid]) {
// 向后面查找(右边)
low = mid + 1;
/*
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
即下次循环 mid = f[k - 1 - 2] - 1
*/
k -= 2;
} else {
// 找到了,需要确定返回的是哪个下标
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
}
如果觉得对你有帮助，欢迎来访我的博客：http://jianjieming.com