Java 查找算法

顺序查找

顺序查找算法是一种最简单的查找算法，它的基本思想是从数组的第一个元素开始，逐个比较，直到找到目标元素或遍历完整个数组。

以下是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方法查找目标值。