1. 在有序数组中查找特定数值

二分查找（Binary Search）最经典的应用场景是在一个有序数组中判断某个数值是否存在。由于数组已经排序，我们可以通过不断将搜索区间减半来将时间复杂度优化至 O(log N)。

/**
 * 检查数组中是否存在目标值
 * @param data 升序排列的数组
 * @param target 待查找的数值
 * @return 存在返回 true，否则返回 false
 */
public static boolean containsValue(int[] data, int target) {
    if (data == null || data.length == 0) {
        return false;
    }
    int low = 0;
    int high = data.length - 1;
    while (low <= high) {
        // 使用该方式防止整数溢出
        int mid = low + ((high - low) >> 1);
        if (data[mid] == target) {
            return true;
        } else if (data[mid] < target) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    return false;
}

2. 查找大于等于目标值的最左侧位置

在某些业务场景下，我们不仅需要知道数值是否存在，还需要找到第一个大于或等于该数值的索引位置。此时，即使 data[mid] == target，我们也需要继续向左侧区间探索，以确认是否有更靠左的符合条件的索引。

/**
 * 寻找 >= target 的最左侧索引
 * @param data 升序排列的数组
 * @param target 阈值
 * @return 符合条件的索引，若无则返回 -1
 */
public static int findLeftmostBoundary(int[] data, int target) {
    if (data == null || data.length == 0) {
        return -1;
    }
    int low = 0;
    int high = data.length - 1;
    int resultIndex = -1; 
    while (low <= high) {
        int mid = low + ((high - low) >> 1);
        if (data[mid] >= target) {
            resultIndex = mid;
            high = mid - 1; // 尝试在左半部分找更小的索引
        } else {
            low = mid + 1;
        }
    }
    return resultIndex;
}

3. 查找小于等于目标值的最右侧位置

同理，若要查找小于或等于目标值的最右侧边界，逻辑与上述相反。当中间值符合条件时，我们记录当前索引并尝试向右侧区间继续压缩。

/**
 * 寻找 <= target 的最右侧索引
 */
public static int findRightmostBoundary(int[] data, int target) {
    if (data == null || data.length == 0) {
        return -1;
    }
    int low = 0;
    int high = data.length - 1;
    int resultIndex = -1;
    while (low <= high) {
        int mid = low + ((high - low) >> 1);
        if (data[mid] <= target) {
            resultIndex = mid;
            low = mid + 1; // 尝试在右半部分找更大的索引
        } else {
            high = mid - 1;
        }
    }
    return resultIndex;
}

4. 无序数组中的局部最小值问题

二分法的使用并不局限于有序数组。只要我们能构建出一种能够排除一半搜索空间的逻辑，就可以使用二分法。在一个相邻元素不相等的无序数组中，寻找任意一个局部最小值就是一个典型的例子。

局部最小值的定义：

• 对于索引 0：若 arr[0] < arr[1]，则 0 是局部最小。
• 对于索引 N-1：若 arr[N-1] < arr[N-2]，则 N-1 是局部最小。
• 对于中间索引 i：若 arr[i-1] > arr[i] 且 arr[i+1] > arr[i]，则 i 是局部最小。

如果边界不是局部最小，说明数组两端呈"下降"趋势。由于数组内部是连续变化的（虽然离散但数值存在大小关系），在两端下降的趋势下，中间必然存在谷底。

/**
 * 寻找数组中的一个局部最小值索引
 * @param arr 相邻元素不相等的数组
 */
public static int getLocalMinimumIndex(int[] arr) {
    if (arr == null || arr.length == 0) {
        return -1;
    }
    int size = arr.length;
    if (size == 1 || arr[0] < arr[1]) {
        return 0;
    }
    if (arr[size - 1] < arr[size - 2]) {
        return size - 1;
    }

    int left = 0;
    int right = size - 1;
    // 使用 left < right - 1 确保 mid 左右都有元素，防止越界
    while (left < right - 1) {
        int mid = left + ((right - left) >> 1);
        if (arr[mid] < arr[mid - 1] && arr[mid] < arr[mid + 1]) {
            return mid;
        }
        // 如果 mid 比左边大，说明左侧必有波谷
        if (arr[mid] > arr[mid - 1]) {
            right = mid - 1;
        } else { 
            // 否则 mid 必比右边大，右侧必有波谷
            left = mid + 1;
        }
    }
    return arr[left] < arr[right] ? left : right;
}

通过局部最小值的例子可以看出，二分查找的核心在于"减治"思想。只要能通过某种策略确定目标值必然存在于剩余的某一半区间中，有序性并非二分法的必要前提。