顺序查找
顺序查找算法是一种最简单的查找算法，它的基本思想是从数组的第一个元素开始，逐个比较，直到找到目标元素或遍历完整个数组。
以下是Java实现的顺序查找算法示例代码：
public class SequentialSearch {public static int search(int[] arr, int key) {for (int i = 0; i < arr.length; i++) {if (arr[i] == key) {return i; // 返回找到元素的索引}}return -1; // 如果未找到，返回-1}public static void main(String[] args) {int[] array = {1, 3, 5, 7, 9};int key = 5;int result = search(array, key);System.out.println("Element found at index: " + result);}
}
在这个示例中，我们定义了一个名为sequentialSearch的方法，它接受一个整数数组和一个目标整数作为参数。方法使用一个循环来遍历整个数组，并在每次迭代中检查当前元素是否等于目标元素。如果找到了目标元素，则返回其索引；否则，返回-1表示未找到目标元素。
二分查找
二分查找算法（Binary Search）是一种在有序数组中查找特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。
以下是Java实现的二分查找算法：
public class BinarySearch {public static int binarySearch(int[] arr, int target) {int left = 0;int right = arr.length - 1;while (left <= right) {int mid = left + (right - left) / 2;if (arr[mid] == target) {return mid;} else if (arr[mid] < target) {left = mid + 1;} else {right = mid - 1;}}return -1;}public static void main(String[] args) {int[] arr = {1, 3, 5, 7, 9};int target = 5;int result = binarySearch(arr, target);System.out.println("目标值 " + target + " 在数组中的索引为： " + result);}
}
这段代码定义了一个名为binarySearch的方法，接受一个整数数组arr和一个整数目标值target作为参数。方法返回目标值在数组中的索引，如果目标值不在数组中，则返回-1。
插值查找
插值查找算法（Interpolation Search）是一种改进的二分查找算法，它根据要查找的关键字在有序数组中的位置来动态调整查找的范围。插值查找的基本思想是：如果要查找的关键字在数组中的位置越靠前，那么查找范围就越大；反之，如果要查找的关键字在数组中的位置越靠后，那么查找范围就越小。
以下是Java实现的插值查找算法：
public class InterpolationSearch {public static int interpolationSearch(int[] arr, int target) {int left = 0;int right = arr.length - 1;while (left <= right && target >= arr[left] && target <= arr[right]) {int pos = left + (target - arr[left]) * (right - left) / (arr[right] - arr[left]);if (arr[pos] == target) {return pos;} else if (arr[pos] < target) {left = pos + 1;} else {right = pos - 1;}}return -1;}public static void main(String[] args) {int[] arr = {1, 3, 5, 7, 9};int target = 5;int result = interpolationSearch(arr, target);System.out.println("目标值 " + target + " 在数组中的索引为： " + result);}
}
这段代码定义了一个名为interpolationSearch的方法，接受一个整数数组arr和一个整数目标值target作为参数。方法返回目标值在数组中的索引，如果目标值不在数组中，则返回-1。
斐波那契查找
斐波那契查找（Fibonacci Search）是一种基于斐波那契数列的查找算法，它通过将待查找的数组分成不均等的两部分来提高查找效率。具体来说，它将数组分为两个部分，其中第一部分的长度为斐波那契数列中的一个数，第二部分的长度为斐波那契数列中的另一个数。然后根据要查找的元素与这两个部分的边界值的关系，来确定下一步查找的范围。
以下是Java实现的斐波那契查找算法：
public class FibonacciSearch {public static int fibonacciSearch(int[] arr, int target) {int low = 0;int high = arr.length - 1;int k = 0; // 斐波那契分割数值的下标// 获取斐波那契数列中的分割数值while (high > arr[k] - 1) {k++;low = high;high = high + arr[k];}// 创建临时数组并复制原数组的前k+1个元素int[] temp = new int[k + 1];for (int i = 0; i < k + 1; i++) {temp[i] = arr[i];}// 在临时数组中进行二分查找while (low <= high) {int mid = low + (high - low) / 2;if (target < temp[mid]) {high = mid - 1;} else if (target > temp[mid]) {low = mid + 1;} else {return mid;}}return -1;}public static void main(String[] args) {int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};int target = 7;int result = fibonacciSearch(arr, target);System.out.println("目标值 " + target + " 在数组中的索引为： " + result);}
}
这段代码定义了一个名为fibonacciSearch的方法，接受一个整数数组arr和一个整数目标值target作为参数。方法返回目标值在数组中的索引，如果目标值不在数组中，则返回-1。
分块查找
分块查找（Block Search）是一种改进的二分查找算法，它将待查找的数组分成若干个大小相等的块，然后在每个块内进行二分查找。这种算法适用于数据量较大、分布不均匀的有序数组。
以下是Java实现的分块查找算法：
public class BlockSearch {public static int blockSearch(int[] arr, int target) {int blockSize = (int) Math.sqrt(arr.length); // 计算块的大小int low = 0;int high = arr.length - 1;while (low <= high) {int mid = low + (high - low) / 2;int blockIndex = mid / blockSize; // 计算mid所在的块的索引int blockStart = blockIndex * blockSize; // 计算块的起始位置int blockEnd = Math.min(blockStart + blockSize - 1, arr.length - 1); // 计算块的结束位置if (target >= arr[blockStart] && target <= arr[blockEnd]) {// 如果目标值在当前块内，则在当前块内进行二分查找return binarySearch(arr, target, blockStart, blockEnd);} else if (target < arr[blockStart]) {high = blockStart - 1;} else {low = blockEnd + 1;}}return -1;}private static int binarySearch(int[] arr, int target, int low, int high) {while (low <= high) {int mid = low + (high - low) / 2;if (arr[mid] == target) {return mid;} else if (arr[mid] < target) {low = mid + 1;} else {high = mid - 1;}}return -1;}public static void main(String[] args) {int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};int target = 7;int result = blockSearch(arr, target);System.out.println("目标值 " + target + " 在数组中的索引为： " + result);}
}
这段代码定义了一个名为blockSearch的方法，接受一个整数数组arr和一个整数目标值target作为参数。方法返回目标值在数组中的索引，如果目标值不在数组中，则返回-1。
哈希查找
哈希查找（Hash Search）是一种基于哈希表的查找算法，它通过将待查找的元素映射到一个哈希表中的位置，然后直接访问该位置来查找元素。哈希查找的时间复杂度为O(1)，因此查找速度非常快。
以下是Java实现的哈希查找算法：
import java.util.HashMap;public class HashSearch {public static int hashSearch(int[] arr, int target) {HashMap<Integer, Integer> map = new HashMap<>();for (int i = 0; i < arr.length; i++) {map.put(arr[i], i); // 将数组元素作为键，下标作为值存入哈希表}return map.getOrDefault(target, -1); // 查找目标值在哈希表中对应的下标，如果不存在则返回-1}public static void main(String[] args) {int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};int target = 7;int result = hashSearch(arr, target);System.out.println("目标值 " + target + " 在数组中的索引为： " + result);}
}
这段代码定义了一个名为hashSearch的方法，接受一个整数数组arr和一个整数目标值target作为参数。方法返回目标值在数组中的索引，如果目标值不在数组中，则返回-1。
树表查找
树表查找（Tree Table Search）是一种基于树形结构的查找算法，它通过将待查找的元素与树表中的节点进行比较，然后根据比较结果在树表中进行递归查找。
以下是Java实现的树表查找算法：
class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) {val = x;}
}public class TreeTableSearch {public static boolean search(TreeNode root, int target) {if (root == null) {return false;}if (root.val == target) {return true;}return search(root.left, target) || search(root.right, target);}public static void main(String[] args) {TreeNode root = new TreeNode(1);root.left = new TreeNode(2);root.right = new TreeNode(3);root.left.left = new TreeNode(4);root.left.right = new TreeNode(5);root.right.left = new TreeNode(6);root.right.right = new TreeNode(7);int target = 5;boolean found = search(root, target);System.out.println("Target " + target + " found: " + found);}
}
这段代码定义了一个名为TreeNode的类，表示树表中的节点。search方法接受一个根节点和一个目标值作为参数，返回一个布尔值表示是否找到了目标值。在main方法中，我们创建了一个简单的树表，并调用search方法查找目标值。
)
