
public int search(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2; // 防止溢出
        int x = nums[mid];
        
        if (x == target) {
            return mid;
        } else if (x > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return -1;
}

方法 2：递归二分查找

除了迭代方式，我们还可以采用递归方式实现二分查找：


public int search(int[] nums, int target) {
    return binarySearch(nums, target, 0, nums.length - 1);
}
 
private int binarySearch(int[] nums, int target, int left, int right) {
    if (left > right) {
        return -1;
    }
    
    int mid = left + (right - left) / 2; // 防止溢出
    int x = nums[mid];
    
    if (x == target) {
        return mid;
    } else if (x > target) {
        return binarySearch(nums, target, left, mid - 1);
    } else {
        return binarySearch(nums, target, mid + 1, right);
    }
}

方法 3：非递归简化版本

有时我们可以进一步简化代码，使其更简洁：


public int search(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        
        if (nums[mid] == target) {
            return mid;
        }
        
        if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

方法 4：带调试信息的版本

为了更好地理解算法，可以添加调试信息来跟踪程序执行过程：


public int search(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        System.out.println("Left: " + left + ", Mid: " + mid + ", Right: " + right);
 
        if (nums[mid] == target) {
            System.out.println("Found target at index: " + mid);
            return mid;
        }
        
        if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    System.out.println("Target not found.");
    return -1;
}

详细步骤

初始化：设置 left 为数组的起始索引 0，right 为数组的末尾索引 n-1。
计算中点：在每个迭代中，计算中点 mid 的索引，避免直接加和可能导致的溢出。
比较中点值：将中点值与目标值 target 比较：
- 若相等，返回中点索引。
- 若中点值大于目标值，将 right 更新为 mid - 1。
- 若中点值小于目标值，将 left 更新为 mid + 1。
重复操作：继续上述步骤直到 left 超过 right，表示目标值不在数组中，返回 -1。

总结

二分查找是一种高效的查找算法，其时间复杂度为 O(log n)，非常适用于大规模有序数组的查找任务。通过本文展示的多种实现方法，你可以灵活选择适合自己场景的实现方式。此外，理解并掌握二分查找的基本原理和细节，将会对提升你的编码能力和解决问题的效率大有裨益。希望这些方法能够帮助你顺利解决 java.util.concurrent.BrokenBarrierException 问题，确保程序顺利运行。

如果本文对你有帮助欢迎关注、点赞、收藏、评论！！！

博主v：XiaoMing_Java

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/796069

推荐阅读

相关标签