顺序查找
public int seqSearch(int[] a, int n) {
for (int i = 0; i < a.length; i++) {
if (a[i] == n) {
return i;
}
}
return -1;
}
二分查找
public static int binarySearch(int[] a, int left, int right, int n) {
if (left > right) {
return -1;
}
int mid = (left + right) / 2;
if (a[mid] == n) {
return mid;
} else if (a[mid] > n) {
return binarySearch(a, left, mid - 1, n);
} else {
return binarySearch(a, mid + 1, right, n);
}
}
// 找到数组中包含的所有被查找值
public static List<Integer> binarySearchAll(int[] a, int left, int right, int n) {
List<Integer> res = new ArrayList<>();
if (left > right) {
return res;
}
int mid = (left + right) / 2;
int tmp = mid - 1;
if (a[mid] == n) {
while (tmp >= 0 && a[tmp] == n) {
res.add(tmp);
tmp--;
}
res.add(mid);
tmp = mid + 1;
while (tmp <= a.length - 1 && a[tmp] == n) {
res.add(tmp);
tmp++;
}
return res;
} else if (a[mid] > n) {
return binarySearchAll(a, left, mid - 1, n);
} else {
return binarySearchAll(a, mid + 1, right, n);
}
}
插值查找
原理介绍:
(1)插值查找类似于二分查找,不同的是插值查找每次从自适应mid处开始查找。
(2)将二分查找中计算mid索引的公式做如下修改(key 为需要查找的值):
public static int insertValueSearch(int[] a, int left, int right, int key) {
if (left > right || key < a[0] || key > a[a.length - 1]) {
return -1;
}
int mid = left + (right -left) * (key - a[left]) / (a[right] - a[left]);
if (a[mid] == key) {
return mid;
} else if (a[mid] > key) {
return insertValueSearch(a, left, mid - 1, key);
} else {
return insertValueSearch(a, mid + 1, right, key);
}
}
适用于数据量大,关键字分布比较均匀的查找表。
斐波那契查找
原理介绍:
将mid的计算改变为:mid = left + 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 = left + F(k - 1) - 1。
(2)顺序表长度不一定刚好等于F(k) - 1,所以需要将原来的顺序表长度n增加至F(k) -1。此处k只要使得F(k) - 1恰好大于或等于n即可。
public class FibonacciSearch {
public static int maxSize = 20;
// 因为计算max = 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 对应下标
*/
public static int fibonacciSearch(int[] a, int key) {
int left = 0;
int right = a.length - 1;
int k = 0; // 表示斐波那契分割数值的下标
int mid = 0;
int[] f = fib();
// 获取斐波那契分割数值的下标k
while (right > f[k] - 1) {
k++;
}
// 因为f(k)值可能大于a的长度,因此我们需要使用Arrays类构造一个新的数组,并指向tmp []
int[] tmp = Arrays.copyOf(a, f[k]);
// 使用a数组最后的数填充tmp
for (int i = right + 1; i < tmp.length; i++) {
tmp[i] = a[right];
}
while (left <= right) {
mid = left + f[k - 1] - 1;
if (key < tmp[mid]) {
right = mid - 1;
// f[k] = f[k - 1] + f[k - 2], f[k - 1] = f[k - 2] + f[k - 3]
// 因此在f[k - 1]的前面继续查找 k--, 即下次循环mid = f[k - 1 - 1] -1
k--;
} else if (key > tmp[mid]) {
left = mid + 1;
// f[k] = f[k - 1] + f[k - 2], 因为后面有f[k-2], 所以继续拆分f[k - 2] = f[k - 3] + f[k - 4]
// 即在f[k-2]前面进行查找k-=2,即下次循环 mid = f[k-1-2] -1
k -= 2;
} else {
return Math.min(mid, right);
}
}
return -1;
}
}