高频刷题-二分查找(Binary Search)专题

leecode 中有很多binary search的题。一般而言，当一个题目出现以下特性时，你就应该立即联想到它可能需要使用二分查找：

1. 待查找的数组有序或者部分有序
2. 要求时间复杂度低于O(n)，或者直接要求时间复杂度为O(log n)

 

二叉搜索的思想很好理解，但是其中的边界条件却很繁琐，很多时候写出来的代码不能很好的处理边界条件。例如：

同时，二叉搜索有很多的变体，例如：

对于这些条件和边界的总结，强烈推荐下面这篇文章，可以说是山高月小，水落石出。

https://leetcode-cn.com/problems/binary-search/solution/er-fen-cha-zhao-xiang-jie-by-labuladong/

下面我们来看具体的题目。

 

首先是一个最原始和典型的二叉搜索的题：

https://leetcode.com/problems/binary-search/

 

这道题很典型，我们采用两种方式进行求解，首先是

public int search(int[] nums, int target) {
        int left = 0, right = nums.length - 1; 
// right取值在数组范围内，为[left, right], 左闭右闭，
// 决定了while循环时采用left <= right
        while(left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) return mid;
            else if (nums[mid] < target) { 
// 分为三部分，[left, mid - 1], mid, [mid + 1, right]，所以left和right分别取mid + 1和mid - 1
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        return -1;
    }

第二种是采用[left, right)的方式，实现代码如下:

public int search(int[] nums, int target) {
        int left = 0, right = nums.length; 
// right取值在数组范围内，为[left, right), 左闭右开，
// 决定了while循环时采用left < right
        int mid = -1;
        
        while(left < right) {
            mid = left + (right - left) / 2;
            if (nums[mid] == target) return mid;
// 分为三部分，[left, mid), mid, [mid+1, right)，所以left和right分别取mid + 1和mid
            else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        
        return -1;
    }

https://leetcode.com/problems/search-insert-position/

 

这个题目是找到insert的位置，和上题是否找到结果相比，只需要在找不到时，返回left即可。当前退出条件为left == right，所以任意返回一个即可。

public int searchInsert(int[] nums, int target) {
        int left = 0, right = nums.length;
        
        while(left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) return mid;
            else if (nums[mid] > target) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        // 退出条件为left == right，所以返回任意一个即可
        return left;
    }

https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/

 

这道题是需要找到第一次出现的位置和最后一次出现的位置，也就是查找两次，一次通过左侧逼近找到左侧的边界，另外一次通过右侧逼近找到右侧边界，返回结果即可。

实现代码上还是采用两种循环方式，分别实现。

采用<= 的方式：

public int[] searchRange(int[] nums, int target) {
        int len = nums.length;
        if (len == 0) return new int[]{-1, -1};

        int[] res = new int[]{-1, -1};
        res[0] = left_bound(nums, target);
        res[1] = right_bound(nums, target);
        return res;
    }

    // 使用[left, right]实现
    private int left_bound(int[] nums, int target) {
        int left = 0, right = nums.length - 1; // [left, right] -> 决定了while循环中采用left <= right
        // 左侧逼近
        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] < target) {  // 本质上是要找到left位置，这个位置表示left的左侧，都是小于target的集合
                left = mid + 1;
            } else if (nums[mid] >= target) { // 对于左侧逼近，就是相等的时候，取right = mid，这样继续查找第一个出现该值的地方
                right = mid - 1;
            }
        }

        // 注意该处没找到时，left可能等于nums.length，nums[left]也会溢出，所以排除这种情况
        if (left < nums.length && nums[left] == target) return left;
        else return -1;
    }

    // 使用[left, right]实现
    private int right_bound(int[] nums, int target) {
        // 右侧逼近
        int left = 0, right = nums.length - 1;  // [left, right] -> 决定了while循环中采用left <= right
        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] > target) {  // 可以理解为right右侧的位置，都是大于target的集合
                right = mid - 1;
            } else if (nums[mid] <= target) {  // 对于右侧逼近，就是相等的时候，取left = mid + 1，这样继续查找最后一个出现该值的地方
                left = mid + 1;
            }
        }

        // 注意这个地方没找到的话left 可能为0，这样-1会溢出
        if (right >= 0 && nums[right] == target) return right;
        else return -1;
}

采用< 的方式，不同之处在与left和right的赋值。

public int[] searchRange(int[] nums, int target) {
        int len = nums.length;
        if (len == 0) return new int[]{-1, -1};

        int[] res = new int[]{-1, -1};
        res[0] = left_search(nums, target);
        res[1] = right_search(nums, target);
        return res;
    }

    private int left_search(int[] nums, int target) {
        int left = 0, right = nums.length;
        // 左侧逼近
        while (left < right) {
            int mid = left + (right - left) / 2;

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

        if (left < nums.length && nums[left] == target) return left;
        else return -1;
    }

    private int right_search(int[] nums, int target) {
        // 右侧逼近
        int left = 0, right = nums.length;
        while (left < right) {
            int mid = left + (right - left) / 2;

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

        if (left >= 1 && nums[left - 1] == target) return left - 1;
        else return -1;
}

https://leetcode.com/problems/guess-number-higher-or-lower/

 

这个感觉没啥好说的.. 把题目看懂最重要.

public int guessNumber(int n) {
        int left = 1, right = n;
        int mid = 0;
        
        while(left <= right) {
            mid = left + (right - left) / 2;
            if (0 == guess(mid)) break;
            else if (1 == guess(mid)) left = mid + 1;
            else right = mid - 1;
        }
        return mid;
    }

 

https://leetcode.com/problems/first-bad-version/

 

这个题相当于找到第一次出现的true，也是采用左侧毕竟的方式实现。代码如下：

public int firstBadVersion(int n) {
        int left = 1, right = n;
        int mid = -1;
        
        while(left < right) {
            mid = left + (right - left) / 2;
            if (isBadVersion(mid)) right = mid; // 找到true，则right = mid
            else left = mid + 1; // 找到的还是false，则left标记为mid + 1
        }
        return left;
    }

https://leetcode.com/problems/find-peak-element/

找到山峰的极值，这个题也可以采用二分查找，要注意由于要对比mid 和mid + 1位置的山峰高度，所以这个时候right 最大只能为length – 1（***特别注意）。

public int findPeakElement(int[] nums) {
        if (nums.length == 1) return 0;
        
        int left = 0, right = nums.length - 1;
        
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < nums[mid + 1]) {  // 上升的曲线上，山峰极值之一在右侧，要注意由于要判断mid + 1，因此上面的right = nums.length - 1，不然会溢出
                left = mid + 1;
            } else {    // 下降的曲线，山峰的极值之一在左侧
                right = mid;
            }
        }
        return left;
    }