查找算法
-
顺序查找算法（Sequential Search Algorithm）：是一种简单的查找算法，它从第一个元素开始依次比较，直到找到要查找的元素，或者搜索到最后一个元素。适用于数据量较小的列表，时间复杂度为 O(n)。
-
二分查找算法（Binary Search Algorithm）：也称作折半查找，它是一种在有序序列中查找特定元素的算法。适用于有序列表，时间复杂度为 O(log n)。
-
插值查找算法（Interpolation Search Algorithm）：在二分查找的基础上优化了查找位置的方法，它根据查找关键字与查找区间的最大值和最小值进行比较，可以更快地找到指定元素。适用于数据均匀分布的有序列表，时间复杂度为 O(log log n)。
-
斐波那契查找算法（Fibonacci Search Algorithm）：利用黄金分割原理，通过斐波那契数列中的数值确定查找点位置，也是一种针对有序序列的查找算法。适用于有序列表，时间复杂度为 O(log n)。
-
树表查找算法（Tree Table Search Algorithm）：基于树型数据结构的查找算法，可以快速定位特定元素，常用的树表包括二叉查找树、AVL树、红黑树等。适用于大规模的动态查找表，时间复杂度为 O(log n)。
-
分块查找算法（Block Search Algorithm）：将数据分成若干块，每块中的元素可以无序，但不同块之间必须按照某种顺序排序，该算法通过索引表进行查找，常用于静态查找。适用于数据分块但内部无序的列表，时间复杂度为 O(sqrt(n))。
-
哈希表查找算法（Hash Table Search Algorithm）：将数据按照哈希函数散列到各个存储位置，通过关键字快速定位目标元素。由于哈希函数有可能出现哈希冲突，因此需要解决冲突问题，常用的解决方法包括链式法和开放寻址法。适用于大规模的静态查找表，时间复杂度为 O(1)。
顺序查找
工作原理是从一个给定的数据集合中，逐一检查每个元素，直到找到给定值或者确定没有给定值存在。它的步骤如下：从第一个元素开始，将它与要查找的值进行比较；如果相等，则查找结束；如果不相等，则继续查找；继续比较下一个元素，重复步骤2和3如果查找到最后一个元素仍然不相等，则结束查找，表明该值不存在。
public static int sequentialSearch(int[] array, int target) {
for (int i = 0; i < array.length; i++) {
if (array[i] == target) {
return i;
}
}
return -1;
}
二分查找
它的操作步骤如下：首先，从有序数组的中间位置开始搜索，如果该元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于要查找的元素，则在数组中间元素的左侧继续进行搜索；反之，如果某一特定元素小于要查找的元素，则在数组中间元素的右侧继续进行搜索。重复以上过程，直到找到要查找的元素，或者查找范围为空。
public static int binarySearch(int[] array, int target) {
int left = 0, right = array.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] == target) {
return mid;
} else if (array[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}
插值查找
插值查找是一种二分查找的变体，其核心是根据查询元素与数组中间元素的比较结果来调整查找范围，以加快查询速度。它的核心思想是：当搜索到一个关键字时，将搜索范围缩小一半，这样比较次数就会减少。它的查找公式为：middle=low+(key-a[low])/(a[high]-a[low])*(high-low)
public static int interpolationSearch(int[] array, int target) {
int low = 0;
int high = array.length - 1;
int mid;
while (low <= high) {
mid = low + (high - low) * (target - array[low]) / (array[high] - array[low]);
if (array[mid] == target) {
return mid;
}
if (array[mid] > target) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return -1;
}
斐波那契查找
斐波那契查找是一种特殊的二分查找，它根据斐波那契序列的特点对有序数组进行分割来查找指定值。通过切割数组的大小来减少搜索时间，它是一种非常高效的查找算法，其时间复杂度在最坏情况下为O(log n)。
public static int fibonacciSearch(int[] arr, int key) {
int low = 0;
int high = arr.length - 1;
int k = 0;
int mid = 0;
int f[] = fibonacci();
while (high > f[k] - 1) {
k++;
}
int[] temp = Arrays.copyOf(arr, f[k]);
for (int i = high + 1; i < temp.length; i++) {
temp[i] = arr[high];
}
while (low <= high) {
mid = low + f[k - 1] - 1;
if (key < temp[mid]) {
high = mid - 1;
k--;
} else if (key > temp[mid]) {
low = mid + 1;
k -= 2;
} else {
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
public static int[] fibonacci() {
int[] f = new int[20];
f[0] = 1;
f[1] = 1;
for (int i = 2; i < 20; i++) {
f[i] = f[i - 1] + f[i - 2];
}
return f;
}
二叉树查找
二叉树查找是一种在二叉搜索树中查找特定键值的搜索算法。在二叉搜索树中，查找过程从根节点开始，如果查找的键值小于根节点的键值，则将查找范围缩小到根节点的左子树，反之则在右子树中查找，直到找到相应的键值或找不到为止。
/* 二叉树节点 */
class Node {
int key;
Node left, right;
public Node(int item) {
key = item;
left = right = null;
}
}
/* 二叉查找树类 */
class BinarySearchTree {
Node root;
/* 构造方法 */
BinarySearchTree() {
root = null;
}
/* 查找 */
public Node search(Node root, int key) {
// 如果根为 null 或者根等于 key，则返回根
if (root == null || root.key == key)
return root;
// 如果根的 key 大于给定的 key，则在左子树中查找
if (root.key > key)
return search(root.left, key);
// 如果根的 key 小于给定的 key，则在右子树中查找
return search(root.right, key);
}
/* 插入 */
public void insert(int key) {
root = insertRec(root, key);
}
/* 插入递归函数 */
Node insertRec(Node root, int key) {
/* 如果根为空，则创建一个新节点 */
if (root == null) {
root = new Node(key);
return root;
}
/* 如果 key 小于根的 key，则在左子树中插入 */
if (key < root.key)
root.left = insertRec(root.left, key);
/* 如果 key 大于根的 key，则在右子树中插入 */
else if (key > root.key)
root.right = insertRec(root.right, key);
/* 返回新树 */
return root;
}
/* 中序遍历 */
public void inorder() {
inorderRec(root);
}
/* 中序遍历递归函数 */
void inorderRec(Node root) {
if (root != null) {
inorderRec(root.left);
System.out.print(root.key + " ");
inorderRec(root.right);
}
}
/* 测试程序 */
public static void main(String[] args) {
BinarySearchTree tree = new BinarySearchTree();
/* 插入节点 */
tree.insert(50);
tree.insert(30);
tree.insert(20);
tree.insert(40);
tree.insert(70);
tree.insert(60);
tree.insert(80);
/* 搜索节点 */
Node foundNode = tree.search(tree.root, 60);
if (foundNode != null)
System.out.println("找到了节点 " + foundNode.key);
else
System.out.println("未找到节点");
/* 中序遍历 */
tree.inorder();
}
}
分块查找
分块查找是一种查找算法，它是一种分而治之的思想，将一个大的数据序列划分成多个小的块，然后在每一个块中进行查找，查询时间就可以大大缩短。
//其中函数 `search` 接受一个整数数组 `arr`、块大小 `blockSize` 和要查找的值 `value`，返回 `value` 在 `arr` 中的位置，如果没有找到，返回 -1。
//该函数首先将数组分成若干块，记录每个块的最大值，然后在块中使用二分查找查找 `value`。
public class BlockSearch {
public static int search(int[] arr, int blockSize, int value) {
int n = arr.length;
int numBlocks = (int) Math.ceil(n / (double) blockSize);
int[] blockMax = new int[numBlocks];
// 分块，记录每个块的最大值
for (int i = 0; i < numBlocks; i++) {
int max = Integer.MIN_VALUE;
for (int j = i * blockSize; j < Math.min(n, (i + 1) * blockSize); j++) {
max = Math.max(max, arr[j]);
}
blockMax[i] = max;
}
// 在块中二分查找
for (int i = 0; i < numBlocks; i++) {
if (value <= blockMax[i]) {
for (int j = i * blockSize; j < Math.min(n, (i + 1) * blockSize); j++) {
if (arr[j] == value) {
return j;
}
}
break;
}
}
return -1; // 没有找到
}
public static void main(String[] args) {
int[] arr = {2, 4, 6, 8, 1, 3, 5, 7, 9};
int blockSize = 3;
int value = 5;
int index = search(arr, blockSize, value);
if (index != -1) {
System.out.println(value + " 在数组中的位置是 " + index);
} else {
System.out.println("没有找到 " + value);
}
}
}
哈希查找
哈希查找是一种速度比较快的查找算法，它使用一种叫哈希函数的函数将数据映射到一个关键字上，以便更快地查找数据。哈希查找的运行时间只与数据的个数有关，而与数据的规模无关，所以它的运行速度是固定的，不会随着数据的增加而减慢。
//我们定义了一个静态数组 `array`，然后实现了一个 `hashSearch` 方法，该方法接受一个关键字 `key`，并使用哈希函数 `key % SIZE` 将该关键字映射为一个索引。
//如果对应的数组元素等于关键字，则返回该元素的索引；否则，向后查找直到找到一个空元素或找遍了整个哈希表为止。如果仍然没有找到，则返回 -1 表示关键字不在数组中。
public static int hashSearch(int[] array, int key) {
int size = array.size();
int hash = key % size;
while (array[hash] != 0) {
if (array[hash] == key) {
return hash;
}
hash = (hash + 1) % size;
}
return -1;
}
相关参考
https://www.cnblogs.com/maybe2030/p/4715035.html
810
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
