概念

二分查找算法也成为折半查找,是一种非常高效的工作于有序数组的查找算法.

实现

需求

现有一个有序数组 arr [1,2,3,4,5,6,7,8,9], 目标值target = 2 ,要求返回目标值target在数组arr中的索引,没有则返回-1;

代码实现

    private int binarySearch(int[] arr, int target) {
        int left=0,right = arr.length-1;
        while (left<=right){
            int mid = (left+right)>>>1;
            if (arr[mid]<target){    // target在arr[mid] 右边
                left=mid+1;
            }else if (target<arr[mid]){   // target在arr[mid] 左边
                right=mid-1;
            }else {           // target和arr[mid]相等
                return mid;   
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int target = 2;
        Demo1 d = new Demo1();
        int ans = d.binarySearch(arr,target);
        System.out.println(ans);   // 1
    }

需求进阶

现有一个有序数组 arr [1,2,3,3,3,3,3,4,5], 目标值target = 3 ,要求返回目标值target在数组arr中第一次/最后一次出现的索引,没有则返回-1;

代码实现

第一次出现

    private int binarySearchLeft(int[] arr, int target) {
        int left = 0,right = arr.length-1;
        int candidate = -1;       // 标记
        while (left<=right){
            int mid = (left+right)>>>1;
            if (arr[mid]<target){  // target 在arr[mid] 右边
                left=mid+1;
            }else if(target<arr[mid]){ // target 在arr[mid] 左边
                right=mid-1;
            }else {             // target和arr[mid]相等
                candidate = mid;   // 标记出mid
                right=mid-1;       // 继续向左寻找没有则返回candidate
            }
        }
        return candidate;
    }

    public static void main(String[] args) {
        Demo2 d=  new Demo2();
        int[] arr = {1,2,3,3,3,3,3,4,5};
        int target = 3;
        int ans = d.binarySearchLeft(arr,target);
        System.out.println(ans);  // 2
    }

最后一次出现

    private int binarySearchRight(int[] arr, int target) {
        int left = 0,right = arr.length-1;
        int candidate = -1;       // 标记
        while (left<=right){
            int mid = (left+right)>>>1;
            if (arr[mid]<target){  // target 在arr[mid] 右边
                left=mid+1;
            }else if(target<arr[mid]){ // target 在arr[mid] 左边
                right=mid-1;
            }else {             // target和arr[mid]相等
                candidate = mid;   // 标记出mid
                left=mid+1;       // 继续向右寻找没有则返回candidate
            }
        }
        return candidate;
    }

    public static void main(String[] args) {
        Demo3 d=  new Demo3();
        int[] arr = {1,2,3,3,3,3,3,4,5};
        int target = 3;
        int ans = d.binarySearchRight(arr,target);
        System.out.println(ans);  // 6
    }

时间复杂度

刷题实战

力扣704,二分查找https://leetcode.cn/problems/binary-search/

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums= [-1,0,3,5,9,12],target= 9输出: 4
解释: 9 出现在nums中并且下标为 4

示例 2:

输入: nums= [-1,0,3,5,9,12],target= 2输出: -1
解释: 2 不存在nums中因此返回 -1

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

力扣35.搜索插入位置https://leetcode.cn/problems/search-insert-position/

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

class Solution {
    /**
     * 搜索插入
     * 最左二分搜索
     * @param nums   数组
     * @param target 目标
     * @return int
     */
    public int searchInsert(int[] nums, int target) {
        int left = 0,right = nums.length-1;

        while (left<=right){
            int mid =(left+right)>>>1;
            if (target<=nums[mid]){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return left;
    }
}

力扣 34.在排序数组中查找元素的第一个和最后一个位置https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int left = leftmost(nums, target);
        int right = rightmost(nums, target);
        int[] ans = {left,right};
        return ans;
    }

    private int rightmost(int[] a, int target) {
        int i = 0, j = a.length - 1;
        int candidate = -1;
        while (i <= j) {
            int m = (i + j) >>> 1;
            if (target < a[m]) {
                j = m - 1;
            } else if (a[m] < target) {
                i = m + 1;
            } else {
                candidate = m;
                i = m + 1;
            }
        }
        return candidate;
    }

    private int leftmost(int[] a, int target) {
        int i = 0, j = a.length - 1;
        int candidate = -1;
        while (i <= j) {
            int m = (i + j) >>> 1;
            if (target < a[m]) {
                j = m - 1;
            } else if (a[m] < target) {
                i = m + 1;
            } else {
                // 记录候选位置
                candidate = m;
                j = m - 1;
            }
        }
        return candidate;
    }
}