【Java实现查找算法】1.顺序查找2.二分查找 3.哈希查找 4.BFPRT，嘿嘿嘿

1. 顺序查找（Linear Search）：

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表示未找到
}

2. 二分查找（Binary Search）：

注意：二分查找要求数组是已排序的。

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;
        }

        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1; // 返回-1表示未找到
}

3. 哈希查找（Hashing）：

哈希查找通常涉及到一个哈希表（HashMap）或哈希集（HashSet），但以下是一个简单的哈希函数示例，它直接映射到数组索引（注意这只是一个示例，实际哈希函数会更复杂）。

import java.util.HashMap;
import java.util.Map;

public class HashSearch {
    public static int hashFunction(int key) {
        // 简单的哈希函数，仅用于示例
        return key % 10; // 假设数组长度为10
    }

    public static int hashSearch(int[] arr, int target) {
        Map<Integer, Integer> hashMap = new HashMap<>();

        // 假设数组已经通过哈希函数映射到哈希表中
        // 在实际应用中，你需要在插入元素时构建这个哈希表

        // 假设的哈希表构建过程（此处省略）

        // 查找
        Integer index = hashMap.get(target);
        if (index != null && index < arr.length && arr[index] == target) {
            return index; // 返回目标在数组中的索引
        }
        return -1; // 返回-1表示未找到
    }

    // 注意：上述hashSearch方法中的hashMap构建过程在实际应用中需要在插入元素时完成。
}

4. BFPRT（快速选择算法）：

快速选择算法是快速排序算法的一个变种，用于在未排序的数组中找到第k小的元素。

public static int quickSelect(int[] arr, int left, int right, int k) {
    if (left == right) {
        return arr[left];
    }

    int pivotIndex = partition(arr, left, right);

    if (k == pivotIndex) {
        return arr[k];
    } else if (k < pivotIndex) {
        return quickSelect(arr, left, pivotIndex - 1, k);
    } else {
        return quickSelect(arr, pivotIndex + 1, right, k);
    }
}

private static int partition(int[] arr, int left, int right) {
    int pivot = arr[right];
    int i = left - 1;

    for (int j = left; j < right; j++) {
        if (arr[j] <= pivot) {
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, right);
    return i + 1;
}

private static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

```java
public static void main(String[] args) {  
    int[] arr = {3, 2, 1, 5, 6, 4};  
    int k = 2; // 查找第2小的元素  
    // 注意：数组索引是从0开始的，所以第2小的元素实际上是索引为1的元素（如果排序后）
    int result = quickSelect(arr, 0, arr.length - 1, k - 1); // 减1是因为我们要的是排序后的第k个位置
    System.out.println("The " + k + "th smallest element is: " + result);
}

由于数组的索引是从0开始的，因此当我们说“第2小的元素”时，实际上我们是在寻找排序后数组中索引为1的元素。所以，在调用quickSelect函数时，我们将k减去了1。

现在，整个quickSelect算法和main方法的实现都已经完成了，你可以运行这个程序来查看结果。在这个例子中，它将输出：

The 2th smallest element is: 2