Java二分查找如何查找多个数

Java 二分查找如何查找多个数：使用二分查找查找多个数的方法有：二分查找单个数并记录索引、在有序数组中使用二分查找查找范围、结合集合框架进行多次二分查找。 其中，最常用的方法是在有序数组中使用二分查找查找范围，这种方法可以有效地缩小搜索空间，提高查找效率。具体实现时，可以先对输入数组进行排序，然后分别对每个目标值进行二分查找，并记录其出现的位置。

一、二分查找的基本原理

二分查找（Binary Search）是一种高效的查找算法，前提是数组必须是有序的。其基本思想是通过将数组不断地二分，从而逐步缩小查找范围。以下是二分查找的基本步骤：

确定中间点：计算数组的中间索引。
比较中间值：将中间索引的值与目标值进行比较。
- 如果中间值等于目标值，则查找成功。
- 如果中间值小于目标值，则目标值在右半部分。
- 如果中间值大于目标值，则目标值在左半部分。
缩小范围：根据比较结果，缩小查找范围，再次进行二分查找，直到找到目标值或范围缩小到无效。

二、在有序数组中查找多个数

为了在有序数组中查找多个数，可以采用以下策略：

数组排序：确保输入数组是有序的。若未排序，使用排序算法（如快速排序）对其进行排序。
多次二分查找：遍历目标数组，对每个目标值进行二分查找，并记录其索引。

1. 数组排序

在Java中，可以使用Arrays.sort()方法对数组进行排序。例如：

import java.util.Arrays;
public class BinarySearchMultiple {
    public static void main(String[] args) {
        int[] array = {5, 3, 6, 2, 10, 1};
        Arrays.sort(array);
        System.out.println("Sorted array: " + Arrays.toString(array));
    }
}

2. 二分查找实现

利用Java标准库中的Arrays.binarySearch()方法进行二分查找。例如：

import java.util.Arrays;
public class BinarySearchMultiple {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 5, 6, 10};
        int target = 5;
        int index = Arrays.binarySearch(array, target);
        if (index >= 0) {
            System.out.println("Element found at index: " + index);
        } else {
            System.out.println("Element not found");
        }
    }
}

三、查找多个数的完整实现

结合排序和二分查找，可以实现查找多个数的功能。以下是一个完整的示例：

import java.util.Arrays;
public class BinarySearchMultiple {
    public static void main(String[] args) {
        int[] array = {5, 3, 6, 2, 10, 1};
        int[] targets = {10, 3, 7};
        // Step 1: Sort the array
        Arrays.sort(array);
        System.out.println("Sorted array: " + Arrays.toString(array));
        // Step 2: Perform binary search for each target
        for (int target : targets) {
            int index = Arrays.binarySearch(array, target);
            if (index >= 0) {
                System.out.println("Element " + target + " found at index: " + index);
            } else {
                System.out.println("Element " + target + " not found");
            }
        }
    }
}

四、优化策略

1. 使用集合框架

对于大量的查找操作，可以考虑使用集合框架，如TreeSet，其内部实现基于红黑树，能提供对有序元素的高效查找。

import java.util.TreeSet;
public class BinarySearchMultipleWithTreeSet {
    public static void main(String[] args) {
        int[] array = {5, 3, 6, 2, 10, 1};
        int[] targets = {10, 3, 7};
        // Step 1: Insert elements into TreeSet
        TreeSet<Integer> treeSet = new TreeSet<>();
        for (int num : array) {
            treeSet.add(num);
        }
        // Step 2: Perform search for each target
        for (int target : targets) {
            if (treeSet.contains(target)) {
                System.out.println("Element " + target + " found");
            } else {
                System.out.println("Element " + target + " not found");
            }
        }
    }
}

2. 自定义二分查找方法

在某些场景下，可以自定义二分查找方法，以便更好地控制查找过程和结果。例如，可以在查找过程中记录查找路径或统计查找次数。

public class CustomBinarySearch {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 5, 6, 10};
        int target = 5;
        int index = binarySearch(array, target);
        if (index >= 0) {
            System.out.println("Element found at index: " + index);
        } else {
            System.out.println("Element not found");
        }
    }
    public static int binarySearch(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;
        int comparisons = 0;
        while (left <= right) {
            comparisons++;
            int mid = left + (right - left) / 2;
            if (array[mid] == target) {
                System.out.println("Total comparisons: " + comparisons);
                return mid;
            }
            if (array[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        System.out.println("Total comparisons: " + comparisons);
        return -1;
    }
}

五、处理重复元素

在实际应用中，数组中可能包含重复元素。在这种情况下，二分查找需要进行一些调整，以确保找到所有匹配的元素。

1. 查找第一个和最后一个出现的位置

可以通过修改标准的二分查找算法，分别查找目标值的第一个和最后一个位置。

public class BinarySearchRange {
    public static void main(String[] args) {
        int[] array = {1, 2, 2, 2, 3, 5, 6, 10};
        int target = 2;
        int firstIndex = findFirstOccurrence(array, target);
        int lastIndex = findLastOccurrence(array, target);
        if (firstIndex != -1 && lastIndex != -1) {
            System.out.println("Element " + target + " found from index " + firstIndex + " to " + lastIndex);
        } else {
            System.out.println("Element " + target + " not found");
        }
    }
    public static int findFirstOccurrence(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;
        int result = -1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (array[mid] == target) {
                result = mid;
                right = mid - 1;
            } else if (array[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return result;
    }
    public static int findLastOccurrence(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;
        int result = -1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (array[mid] == target) {
                result = mid;
                left = mid + 1;
            } else if (array[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return result;
    }
}

六、总结

通过以上方法，可以有效地在Java中使用二分查找查找多个数。为了提高查找效率，建议先对数组进行排序，然后采用合适的查找策略。对于需要处理重复元素的情况，可以采用查找范围的方法，确保找到所有匹配的元素。

总之，二分查找是一种非常高效的查找算法，通过合理的策略和优化，可以在实际应用中发挥重要作用。