Java 复习笔记 - 常见算法：查找算法

---

算法概述

算法是一系列解决问题的明确指令或步骤。它是一个通过一系列有限而明确的指令，以确定和解决问题的有序过程。算法可以描述为一个计算模型，它转换输入数据为输出结果。

算法通常由一些基本操作组成，这些基本操作可以按照一定的顺序执行，以完成特定的任务。算法可以用来解决各种问题，如搜索、排序、图形处理、数据压缩、人工智能等。

算法的特点包括：

1. 明确性：算法必须清楚地描述每个步骤和操作，使其能够被正确执行。
2. 有限性：算法必须在有限时间内停止运行，不能无限循环或无限执行。
3. 输入：算法有零个或多个输入，这些输入是用来执行算法的数据或信息。
4. 输出：算法产生一个或多个输出，这些输出是算法处理输入数据后的结果。
5. 确定性：在给定相同的输入条件下，算法的执行步骤和结果应该是相同的。
6. 可行性：算法应该是可行的，即可以实际应用并在合理的时间内完成。

通过设计和实现高效和正确的算法，可以提高问题解决的效率和准确性。算法是计算机科学和编程的核心基础之一。

一，基本查找/线性查找

（一）算法简介

线性查找算法，也称为顺序查找算法，是一种基本的查找算法，适用于无序数据集。其基本思想是从数据集的第一个元素开始逐个比较，直到找到目标元素或遍历完整个数据集。

线性查找算法的时间复杂度为O(n)，其中n为数据集的大小。由于需要逐个比较数据集中的元素，所以在最坏情况下，即目标元素位于数据集的最后一个位置，需要遍历整个数据集。

线性查找算法简单易懂，适用于小型数据集或数据集无序的情况，但对于大型数据集效率较低。在有序数据集中，二分查找等其他高效的查找算法可能更适合使用。

（二）算法原理

线性查找算法的原理如下：

1. 首先，从数据集的第一个元素开始，将其与目标元素进行比较。

2. 如果当前元素与目标元素相等，则查找成功，返回当前元素的位置或其他所需的信息。

3. 如果当前元素与目标元素不相等，则继续查找下一个元素。

4. 重复步骤2和步骤3，直到找到目标元素或遍历完整个数据集。

5. 如果遍历完整个数据集仍未找到目标元素，则查找失败。

（三）示例

以下是一个使用基本查找算法的Java示例代码：

public class LinearSearch {
    public static int linearSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;  // 找到目标元素，返回其索引
            }
        }
        return -1;  // 未找到目标元素，返回-1
    }

    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 7, 4};
        int target = 7;
        int result = linearSearch(arr, target);
        if (result == -1) {
            System.out.println("目标元素不存在");
        } else {
            System.out.println("目标元素在索引" + result + "处");
        }
    }
}

在上述示例代码中，linearSearch方法使用线性查找算法来查找目标元素。它接受一个整数数组arr和一个目标元素target作为输入，并返回目标元素在数组中的索引，如果未找到目标元素则返回-1。main方法中的示例展示了如何调用linearSearch方法来查找数组中的元素7，并根据返回结果打印相应的消息。

二，折半查找/二分查找

（一）算法简介

二分查找（Binary Search）算法是一种高效的查找算法，前提是数据必须是有序的。它通过将目标值与数组的中间元素进行比较，并根据比较结果将查找范围缩小一半，不断重复这个过程，直到找到目标元素或者确认目标元素不存在。

二分查找算法的时间复杂度是O(log n)，其中n是数组的大小。这是因为每次查找都会将查找范围缩小一半，所以最坏情况下需要进行log n次比较。

需要注意的是，二分查找算法只适用于有序数组。如果数组是无序的，需要先对数组进行排序，然后再进行二分查找。

（二）算法原理

二分查找算法的原理是将目标值与数组的中间元素进行比较，并根据比较结果将查找范围缩小一半，不断重复这个过程，直到找到目标元素或者确认目标元素不存在。

具体步骤如下：

1. 确定查找范围的左右边界。初始时，左边界为数组的第一个元素索引，右边界为数组的最后一个元素索引。

2. 计算查找范围的中间元素索引（取左右边界的平均值）。

3. 将目标值与中间元素进行比较：

   • 如果目标值等于中间元素，则找到目标元素，返回中间元素的索引。
   • 如果目标值小于中间元素，则目标元素可能在中间元素的左侧，更新右边界为中间元素的索引减1。
   • 如果目标值大于中间元素，则目标元素可能在中间元素的右侧，更新左边界为中间元素的索引加1。

4. 在新的查找范围内，重复步骤2和步骤3，直到找到目标元素或者确认目标元素不存在（左边界大于右边界）。

（三）示例

下面是一个使用二分查找算法的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; // 目标元素不存在，返回-1
    }

    public static void main(String[] args) {
        int[] arr = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
        int target = 23;
        int result = binarySearch(arr, target);
        
        if (result == -1) {
            System.out.println("目标元素不存在");
        } else {
            System.out.println("目标元素的索引为 " + result);
        }
    }
}

在上面的示例中，定义了一个名为binarySearch的静态方法，它接受一个有序数组arr和目标值target作为参数，并返回目标值在数组中的索引（如果存在）或者-1（如果不存在）。

在binarySearch方法中，使用了一个while循环来不断缩小查找范围，直到找到目标元素或者确认目标元素不存在。在每次循环中，通过计算中间元素的索引mid，将目标值与中间元素进行比较，并根据比较结果更新左边界或右边界。

在main方法中，定义了一个有序数组arr和一个目标值target，然后调用binarySearch方法进行查找，并根据返回结果输出相应的信息。

运行上述代码，输出结果为：

目标元素的索引为 5

说明目标元素23在数组中的索引为5。

三，插值查找

（一）算法简介

插值查找算法是一种改进的二分查找算法，它在有序数组中查找目标元素的位置。与二分查找算法相比，插值查找算法通过根据目标值的估计位置来动态确定查找范围，从而提高查找速度。

插值查找算法的思想是根据目标元素与数组中最小元素和最大元素的比较，估计目标元素在数组中的大致位置。

插值查找算法的时间复杂度为O(log n)，其中n是数组的长度。在查找范围较大且元素分布均匀的情况下，插值查找算法的效率比二分查找算法更高。但是在查找范围较小且元素分布不均匀的情况下，插值查找算法可能会比二分查找算法效率低。

（二）算法原理

插值查找算法的原理是根据目标元素与数组中最小元素和最大元素之间的比较，估计目标元素在数组中的大致位置，从而动态确定查找范围，快速定位目标元素的位置。

具体的查找过程如下：

1. 计算目标元素在数组中的估计位置。首先，通过线性插值公式计算插值位置：pos = left + (target - arr[left]) * (right - left) / (arr[right] - arr[left])。其中，left和right分别表示当前查找范围的左右边界，target表示目标元素的值。该公式根据目标元素与数组中最小元素和最大元素之间的比较来估计目标元素在数组中的位置。

2. 如果目标元素等于估计位置上的元素，说明找到了目标元素，返回估计位置。

3. 如果目标元素小于估计位置上的元素，说明目标元素在左侧，更新右边界为估计位置减一，然后回到步骤1。

4. 如果目标元素大于估计位置上的元素，说明目标元素在右侧，更新左边界为估计位置加一，然后回到步骤1。

5. 如果左边界大于右边界，说明目标元素不存在，返回-1。

（三）示例

以下是一个使用插值查找算法的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]) {
            if (left == right) {
                if (arr[left] == target)
                    return left;
                return -1;
            }

            int pos = left + (target - arr[left]) * (right - left) / (arr[right] - arr[left]);

            if (arr[pos] == target)
                return pos;

            if (arr[pos] < target)
                left = pos + 1;
            else
                right = pos - 1;
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
        int target = 16;
        int result = interpolationSearch(arr, target);
        if (result == -1)
            System.out.println("Element not found");
        else
            System.out.println("Element found at index " + result);
    }
}

在这个示例中，定义了一个interpolationSearch方法来执行插值查找算法。该方法接受一个已排序的数组arr和目标元素target作为参数，并返回目标元素的索引，如果目标元素不存在则返回-1。

在interpolationSearch方法中，使用了一个循环来不断更新查找范围。在每次循环中，首先通过线性插值公式计算插值位置pos。然后，检查插值位置上的元素与目标元素的关系，如果相等则找到了目标元素，返回插值位置。如果插值位置上的元素小于目标元素，说明目标元素在右侧，更新左边界为插值位置加一。如果插值位置上的元素大于目标元素，说明目标元素在左侧，更新右边界为插值位置减一。如果左边界大于右边界，说明目标元素不存在，返回-1。

在main方法中，定义了一个示例数组arr和目标元素target，然后调用interpolationSearch方法来执行插值查找算法。最后，根据返回的结果输出查找结果。

四，斐波那契查找

（一）算法简介

斐波那契查找算法是一种基于二分查找的优化算法，它利用了斐波那契数列的特性来确定查找范围。

斐波那契数列是一个无限序列，每个数字都是前两个数字之和。通常，斐波那契数列的前几个数字是：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …

在斐波那契查找算法中，首先需要确定一个斐波那契数列作为查找范围的边界。然后，根据目标元素与边界元素的比较结果，不断缩小查找范围。

斐波那契查找算法的优点是在某些情况下比二分查找更快。它可以有效地缩小查找范围，减少比较的次数。然而，斐波那契查找算法的实现相对复杂，并且需要额外的空间来存储斐波那契数列。因此，在实际应用中，它的使用相对较少。

（二）算法原理

斐波那契查找算法的原理基于斐波那契数列的特性，通过将数组分割为两个部分来不断缩小查找范围。

算法步骤如下：

1. 初始化斐波那契数列的前两个元素为F[0] = 0和F[1] = 1，以及斐波那契数列的下一个元素为F[i] = F[i-1] + F[i-2]。
2. 找到最小的F[k]，使得F[k]大于等于数组的长度。可以通过递增k来计算斐波那契数列。
3. 初始化两个指针：left指向数组的起始位置，right指向数组的结束位置。
4. 使用斐波那契数列中的F[k]将数组分割为两个部分。将指针mid设置为left加上F[k-1]的位置。
5. 比较目标元素与指针mid位置上的元素：
   • 如果目标元素等于mid位置上的元素，则找到了目标元素，返回mid。
   • 如果目标元素小于mid位置上的元素，则目标元素可能在左侧部分，更新right为mid-1。
   • 如果目标元素大于mid位置上的元素，则目标元素可能在右侧部分，更新left为mid+1。
6. 重复步骤4和5，直到目标元素被找到或者left大于right。

（三）示例

以下是斐波那契查找算法的Java示例代码：

public class FibonacciSearch {
    public static int fibonacciSearch(int[] arr, int target) {
        int n = arr.length;
        int fib2 = 0; // F(k-2)
        int fib1 = 1; // F(k-1)
        int fib = fib2 + fib1; // F(k)
        
        // 找到最小的斐波那契数列元素大于等于数组长度
        while (fib < n) {
            fib2 = fib1;
            fib1 = fib;
            fib = fib2 + fib1;
        }
        
        int offset = -1;
        
        while (fib > 1) {
            int i = Math.min(offset + fib2, n - 1);
            
            // 如果目标元素小于当前位置的元素，将查找范围缩小到左侧部分
            if (arr[i] > target) {
                fib = fib2;
                fib1 = fib1 - fib2;
                fib2 = fib - fib1;
            }
            // 如果目标元素大于当前位置的元素，将查找范围缩小到右侧部分
            else if (arr[i] < target) {
                fib = fib1;
                fib1 = fib2;
                fib2 = fib - fib1;
                offset = i;
            }
            // 找到目标元素
            else {
                return i;
            }
        }
        
        // 最后进行一次比较，查找最后一个元素
        if (fib1 == 1 && arr[offset + 1] == target) {
            return offset + 1;
        }
        
        return -1; // 目标元素不存在
    }
    
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13};
        int target = 7;
        int index = fibonacciSearch(arr, target);
        
        if (index != -1) {
            System.out.println("目标元素 " + target + " 在数组中的索引为 " + index);
        } else {
            System.out.println("目标元素 " + target + " 不存在于数组中");
        }
    }
}

此示例代码演示了如何使用斐波那契查找算法在一个有序数组中查找目标元素。在这个示例中，我们将目标元素设置为7，如果目标元素存在于数组中，将打印出目标元素在数组中的索引。否则，将打印出目标元素不存在于数组中的消息。

五，分块查找

（一）算法简介

分块查找算法，也称为块搜素算法，是一种查找算法，适用于一组有序数据被划分成多个块的情况。它结合了顺序查找和二分查找的优点，旨在提高查找效率。

分块查找算法的基本思想是将数据分为多个块，并为每个块建立索引。每个块内部的数据可以是无序的，但是块与块之间的顺序是有序的。通常，每个块的大小相等，但也可以根据实际情况进行不等大小的划分。

在进行查找时，首先根据索引找到目标所在的块，然后在该块内部进行顺序查找或其他查找算法，直到找到目标元素或确定目标元素不在块中。

分块查找算法的时间复杂度为O(sqrt(n))，其中n是数据的总数量。相对于顺序查找的线性时间复杂度O(n)，分块查找的效率更高。

需要注意的是，分块查找算法适用于静态数据，也就是数据不会频繁插入、删除或修改的情况。如果数据经常变动，那么需要重新构建块的索引，可能会导致算法的效率下降。

（二）算法原理

分块查找算法的原理如下：

1. 将待查找的数据分为若干块，每块包含一定数量的元素。每块内部的元素可以是无序的，但是块与块之间的顺序是有序的。

2. 构建块的索引，记录每个块的起始位置和结束位置。通常使用一个索引表来存储这些信息。

3. 根据目标元素的值，在索引表中查找到目标元素所在的块。

4. 在找到的块内部进行顺序查找或其他查找算法，直到找到目标元素或确定目标元素不在块中。

5. 如果目标元素存在于块中，则返回该元素的位置；如果目标元素不存在于块中，则返回不存在的标记。

（三）示例

下面是一个使用分块查找算法的Java示例：

public class BlockSearch {
    
    // 分块查找算法
    public static int blockSearch(int[] arr, int target) {
        // 块的大小
        int blockSize = (int) Math.sqrt(arr.length);
        
        // 构建索引表
        int[] indexTable = new int[blockSize];
        for (int i = 0; i < blockSize; i++) {
            indexTable[i] = arr[i * blockSize];
        }
        
        // 在索引表中查找目标元素所在的块
        int blockIndex = 0;
        while (blockIndex < blockSize && target > indexTable[blockIndex]) {
            blockIndex++;
        }
        
        // 在找到的块内部进行顺序查找
        int start = (blockIndex == 0) ? 0 : (blockIndex - 1) * blockSize;
        int end = Math.min(blockIndex * blockSize, arr.length - 1);
        
        for (int i = start; i <= end; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        
        // 目标元素不存在
        return -1;
    }
    
    public static void main(String[] args) {
        int[] arr = {3, 8, 14, 16, 20, 25, 30, 36, 42, 49, 55, 63, 68, 70, 78, 85, 92};
        int target = 36;
        
        int index = blockSearch(arr, target);
        
        if (index != -1) {
            System.out.println("目标元素 " + target + " 在数组中的位置为：" + index);
        } else {
            System.out.println("目标元素 " + target + " 不存在于数组中");
        }
    }
}

运行以上代码，将会输出：

目标元素 36 在数组中的位置为：7

在这个示例中，将数组分为若干块，每块的大小为4。然后构建了索引表，记录了每个块的起始位置。通过索引表，可以快速定位到目标元素所在的块。在找到的块内部进行顺序查找，最终找到了目标元素的位置。

六，扩展的分块查找

（一）算法简介

扩展的分块查找算法在传统的分块查找算法基础上进行了改进，主要包括以下几个方面的扩展：

1. 块的大小不固定：传统的分块查找算法中，每个块的大小是固定的。而在扩展的分块查找算法中，可以根据实际情况，动态地调整每个块的大小。这样可以根据数据的分布情况，使得每个块的大小更加合适，提高查找效率。

2. 块内元素的排序方式不固定：传统的分块查找算法中，块内的元素必须是有序的。而在扩展的分块查找算法中，可以根据具体需求，选择不同的排序方式。例如，可以使用快速排序、归并排序等算法对每个块内的元素进行排序。

3. 块之间的关系不固定：传统的分块查找算法中，块与块之间必须是有序的。而在扩展的分块查找算法中，可以根据实际情况，决定块与块之间的关系。例如，可以选择将块之间的最大元素作为索引表，或者使用其他数据结构来表示块之间的关系。

4. 支持动态数据更新：传统的分块查找算法主要适用于静态数据，即数据不会发生变化。而扩展的分块查找算法可以支持动态数据的更新。当数据发生变化时，可以通过重新构建索引表或者调整块的大小来维护数据的有序性。

扩展的分块查找算法可以根据实际需求进行灵活调整，以提高查找效率，并适应动态数据的变化。它在一些特定的场景中具有较高的效率和灵活性，例如数据库索引、搜索引擎等。

（二）算法原理

扩展的分块查找算法的原理可以概括为以下几个步骤：

1. 划分块：将有序数组划分为多个块，并确定每个块的大小。块的大小可以根据实际情况进行动态调整，以使得每个块的大小更加合适。

2. 块内排序：对每个块内的元素进行排序。可以选择不同的排序算法，如快速排序、归并排序等。

3. 构建索引表：根据块的关系，构建索引表。索引表可以选择将每个块的起始位置作为索引，或者选择块内的最大元素作为索引。索引表可以采用数组、链表等数据结构表示。

4. 查找操作：根据待查找的元素，通过索引表找到对应的块，并在该块内进行查找。可以使用二分查找、插值查找等方式在块内进行查找。

5. 数据更新：当数据发生变化时，需要进行相应的维护操作。可以通过重新构建索引表、调整块的大小等方式来保持数据的有序性。

扩展的分块查找算法的原理主要是将有序数组划分为多个块，并在块内使用适当的排序方式和查找方法。通过构建索引表和灵活调整块的大小，可以提高查找效率，并支持动态数据的更新。这种算法在一些特定的场景中具有较高的效率和灵活性，适用于大规模数据的查找和维护。

（三）示例

下面是一个示例的 Java 代码，演示了扩展的分块查找算法的实现：

import java.util.Arrays;

public class ExtendedBlockSearch {
    private int[] arr; // 有序数组
    private int blockSize; // 块的大小

    public ExtendedBlockSearch(int[] arr, int blockSize) {
        this.arr = arr;
        this.blockSize = blockSize;
    }

    public int search(int target) {
        int blockIndex = findBlock(target); // 找到目标元素所在的块索引
        if (blockIndex == -1) {
            return -1; // 目标元素不存在
        }

        int start = blockIndex * blockSize; // 块的起始位置
        int end = Math.min(start + blockSize, arr.length); // 块的结束位置

        // 在块内进行二分查找
        int index = Arrays.binarySearch(arr, start, end, target);
        if (index >= 0) {
            return index; // 目标元素存在，返回索引
        } else {
            return -1; // 目标元素不存在
        }
    }

    private int findBlock(int target) {
        // 使用线性查找找到目标元素所在的块索引
        for (int i = 0; i < arr.length; i += blockSize) {
            if (arr[i] > target) {
                return (i - blockSize) / blockSize;
            }
        }
        return (arr.length - 1) / blockSize; // 目标元素在最后一个块中
    }

    public static void main(String[] args) {
        int[] arr = {1, 4, 7, 9, 13, 16, 20, 24, 28, 30};
        int blockSize = 3;
        ExtendedBlockSearch search = new ExtendedBlockSearch(arr, blockSize);

        int target = 13;
        int index = search.search(target);
        if (index != -1) {
            System.out.println("找到目标元素 " + target + "，索引为 " + index);
        } else {
            System.out.println("未找到目标元素 " + target);
        }
    }
}

这个示例中，定义了一个 ExtendedBlockSearch 类来实现扩展的分块查找算法。在构造函数中接受有序数组 arr 和块的大小 blockSize。search 方法用于查找目标元素，首先根据目标元素找到所在的块索引，然后在该块内使用二分查找进行查找。findBlock 方法用于线性查找目标元素所在的块索引。在 main 方法中，创建了一个示例对象，并使用 search 方法查找目标元素 target 的索引。最后输出查找结果。

七，哈希查找

（一）算法简介

哈希查找算法，也称为散列查找算法，是一种通过将关键字映射到数组索引的方式实现查找的算法。它通过构建哈希表来加快查找速度，将查找的时间复杂度从 O(n) 降低到 O(1)。

哈希查找算法的基本思想是，根据关键字通过哈希函数计算出一个哈希值（也叫哈希码），然后将该哈希值作为数组的索引，将关键字存储在数组中。当需要查找某个关键字时，通过哈希函数计算出哈希值，并在数组中查找该索引位置的元素。如果该位置为空，则说明关键字不存在；如果该位置不为空，则可能存在冲突（即多个关键字的哈希值相同），此时需要进一步处理冲突。

常见的处理冲突的方式有两种：链地址法和开放地址法。链地址法利用链表将具有相同哈希值的关键字连接起来，每个数组位置存储首个关键字的指针。开放地址法则通过一定的规则，找到下一个可用的数组位置，直到找到目标关键字或者数组位置为空。

哈希查找算法的优点是查找速度快，只需一次哈希计算和一次数组访问即可找到目标元素。它适用于快速查找大量数据的场景，如数据库索引、缓存等。但是，它也存在一些缺点，例如哈希冲突可能导致性能下降，需要额外的空间来存储哈希表，且哈希函数的设计可能影响到查找效率。

在实际应用中，哈希查找算法常常与其他数据结构和算法相结合，以实现更高效的查找。例如，可以使用哈希表来优化二叉查找树的查询操作，实现更高效的字典查找。

（二）算法原理

哈希查找算法的原理如下：

1. 构建哈希表：首先需要创建一个数组作为哈希表，数组的大小一般根据数据量和冲突情况来确定。每个数组位置被称为槽位，用于存储关键字。

2. 哈希函数：定义一个哈希函数，它将关键字映射到数组索引。哈希函数应该满足以下条件：

   • 对于相同的关键字，哈希函数应该保证计算出的哈希值相同。
   • 哈希函数应尽量将关键字均匀地分布到数组的不同槽位，以减小冲突的概率。

3. 哈希值计算和存储：将待查找的关键字通过哈希函数计算出哈希值，并将其存储在哈希表的对应槽位中。如果该槽位已经被占用，则需要处理冲突。

4. 冲突处理：当多个关键字的哈希值相同时，称为哈希冲突。常见的解决冲突的方法有两种：链地址法和开放地址法。

   • 链地址法：将具有相同哈希值的关键字连接成一个链表，将链表的头指针存储在槽位中。当需要查找关键字时，首先通过哈希函数计算哈希值，然后遍历对应槽位上的链表，直到找到目标关键字或者链表结束。
   • 开放地址法：当槽位被占用时，通过一定的规则找到下一个可用的槽位，直到找到目标关键字或者槽位为空。常见的规则有线性探测、二次探测和双重哈希等。

5. 查找操作：当需要查找关键字时，首先通过哈希函数计算出哈希值，并访问对应槽位。如果槽位为空，则说明关键字不存在；如果槽位不为空，则需要进一步处理冲突。

（三）示例

下面是一个使用哈希查找算法的Java示例代码：

import java.util.LinkedList;

public class HashSearch {

    private int size; // 哈希表的大小
    private LinkedList<Integer>[] hashTable; // 哈希表

    public HashSearch(int size) {
        this.size = size;
        hashTable = new LinkedList[size];
    }

    // 哈希函数，将关键字映射到数组索引
    private int hashFunction(int key) {
        return key % size;
    }

    // 插入关键字到哈希表
    public void insert(int key) {
        int index = hashFunction(key);
        if (hashTable[index] == null) {
            hashTable[index] = new LinkedList<>();
        }
        hashTable[index].add(key);
    }

    // 查找关键字是否存在
    public boolean search(int key) {
        int index = hashFunction(key);
        if (hashTable[index] != null) {
            for (int k : hashTable[index]) {
                if (k == key) {
                    return true;
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        HashSearch hashSearch = new HashSearch(10);
        hashSearch.insert(1);
        hashSearch.insert(5);
        hashSearch.insert(8);

        System.out.println(hashSearch.search(1)); // 输出: true
        System.out.println(hashSearch.search(3)); // 输出: false
    }
}

在上述示例中，首先创建了一个大小为10的哈希表。然后使用哈希函数将关键字映射到数组索引，并将关键字插入对应的槽位。最后，通过调用search方法，可以判断关键字是否存在于哈希表中。输出结果为true表示关键字存在，输出结果为false表示关键字不存在。