查找算法

1. 顺序查找算法（Sequential Search Algorithm）：是一种简单的查找算法，它从第一个元素开始依次比较，直到找到要查找的元素，或者搜索到最后一个元素。适用于数据量较小的列表，时间复杂度为 O(n)。

2. 二分查找算法（Binary Search Algorithm）：也称作折半查找，它是一种在有序序列中查找特定元素的算法。适用于有序列表，时间复杂度为 O(log n)。

3. 插值查找算法（Interpolation Search Algorithm）：在二分查找的基础上优化了查找位置的方法，它根据查找关键字与查找区间的最大值和最小值进行比较，可以更快地找到指定元素。适用于数据均匀分布的有序列表，时间复杂度为 O(log log n)。

4. 斐波那契查找算法（Fibonacci Search Algorithm）：利用黄金分割原理，通过斐波那契数列中的数值确定查找点位置，也是一种针对有序序列的查找算法。适用于有序列表，时间复杂度为 O(log n)。

5. 树表查找算法（Tree Table Search Algorithm）：基于树型数据结构的查找算法，可以快速定位特定元素，常用的树表包括二叉查找树、AVL树、红黑树等。适用于大规模的动态查找表，时间复杂度为 O(log n)。

6. 分块查找算法（Block Search Algorithm）：将数据分成若干块，每块中的元素可以无序，但不同块之间必须按照某种顺序排序，该算法通过索引表进行查找，常用于静态查找。适用于数据分块但内部无序的列表，时间复杂度为 O(sqrt(n))。

7. 哈希表查找算法（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);elseSystem.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