LeetCode精选题之二分查找

最新推荐文章于 2022-07-11 08:22:59 发布

何时立秋丷

最新推荐文章于 2022-07-11 08:22:59 发布

阅读量293

点赞数

分类专栏： # LeetCode刷题文章标签：二分法

本文链接：https://blog.csdn.net/heshiliqiu/article/details/107646786

版权

LeetCode刷题专栏收录该内容

16 篇文章 1 订阅

订阅专栏

文章目录

LeetCode精选题之二分查找

LeetCode精选题之二分查找

参考资料：
1、Cyc2018的题解
2、liweiwei1419的二分查找问题总结

1 x的平方根–LeetCode69

实现 int sqrt(int x)函数。计算并返回 x的平方根，其中 x是非负整数。由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2

示例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
     由于返回类型是整数，小数部分将被舍去。

思路：一个数的平方根最多不会超过它的一半，使用如下公式确定这个数的边界：

${\frac{a}{2}}^2 \ge a$

解以上不等式得 $\ge 4$ 或者 $\le 0$ 。那么大于等于4的数a只需要在1到 $\frac{a}{2}$ 之间找所求的平方根，对于0、1、2、3就要单独考虑，这4个数的平方根依次是0、1、1、1。编程中我们只需要单独考虑0即可，1、2、3可以和后面的数一起考虑，因为这三个数根本就不会走while循环，最后返回left的值，即为1。

注意点：

针对特殊测试用例，例如 2147395599，要把搜索的范围设置成长整型；
这里的中点mid一定要去右中位数，否则可能会进入死循环。举例如下：
当 x = 9 时，如果取的是左中位数

left  right  mid
1        4       2     2*2 < 9
2        4       3     3*3 = 9
3        4       3     3*3 = 9
...
进入死循环
...

代码如下：

class Solution {
    public int mySqrt(int x) {
        if (x == 0) {
            return 0;
        }
        long left = 1, right = x/2;
        while (left < right) {
            // 注意：这里取的是右中位数
            long mid = left + (right-left+1)/2;
            long square = mid*mid;
            if (square > x) {
                right = mid-1;
            }else {
                left = mid;
            }
        }
        return (int)left;
    }
}

参考题解： liweiwei1419的题解

2 寻找比目标字母大的最小字母–LeetCode744

给你一个排序后的字符列表 letters，列表中只包含小写英文字母。另给出一个目标字母 target，请你寻找在这一有序列表里比目标字母大的最小字母。

注意：在比较时，字母是依序循环出现的。举个例子：如果目标字母 target = ‘z’ 并且字符列表为 letters = [‘a’, ‘b’]，则答案返回 ‘a’

示例：

输入:
letters = ["c", "f", "j"]
target = "a"
输出: "c"

输入:
letters = ["c", "f", "j"]
target = "c"
输出: "f"

输入:
letters = ["c", "f", "j"]
target = "d"
输出: "f"

输入:
letters = ["c", "f", "j"]
target = "g"
输出: "j"

输入:
letters = ["c", "f", "j"]
target = "j"
输出: "c"

输入:
letters = ["c", "f", "j"]
target = "k"
输出: "c"

提示：

letters长度范围在[2, 10000]区间内。
letters 仅由小写字母组成，最少包含两个不同的字母。
目标字母target 是一个小写字母。

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

3 有序数组中的单一元素–LeetCode540（Medium）

给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

示例 1:

输入: [1,1,2,3,3,4,4,8,8]
输出: 2

示例 2:

输入: [3,3,7,7,10,11,11]
输出: 10

注意: 您的方案应该在 O(log n)时间复杂度和 O(1)空间复杂度中运行。

解释：取到中点mid之后，判断mid位置和后一个位置是否相等，相等意味着mid 和 mid+1 位置的元素是一对，此时mid指向的是一对数字中的左边一个，让mid–，使得mid指向前一个，这样做的目的是判断left和mid之间的元素个数是奇数还是偶数，讨论如下：

若是奇数，表示单一元素在[left, mid]范围内；
若是偶数，表示单一元素在[mid+1, right]范围内。

回到对mid的处理，如果mid指向的是一对数字中的左边一个，就没法通过left和mid之间的元素个数来判断单一元素在哪边。

class Solution {
    public int singleNonDuplicate(int[] nums) {
        int left = 0, right = nums.length-1;
        while (left < right) {
            int mid = left + (right - left)/2;
            if (nums[mid] == nums[mid+1]) {
                mid--;
            }
            int numCnt = mid-left+1;
            if ((numCnt&1) == 1) {// 奇数个
                right = mid;
            }else {
                left = mid+1;
            }
        }
        return nums[right];
    }
}

4 第一个错误的版本–LeetCode278

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n个版本[1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 boolean isBadVersion(int version)接口来判断版本号 version是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例:

给定 n = 5，并且 version = 4 是第一个错误的版本。

调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true

所以，4 是第一个错误的版本。

思路：如果第 mid 个版本出错，则表示第一个错误的版本在 [left, mid] 之间，令 right = mid；否则第一个错误的版本在 [mid + 1, right] 之间，令 left = mid + 1。

代码如下：

/* The isBadVersion API is defined in the parent class VersionControl.
      boolean isBadVersion(int version); */

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        int left = 1, right = n;
        while (left < right) {
            int mid = left + (right-left)/2;
            if (isBadVersion(mid)) {
                right = mid;
            }else {
                left = mid+1;
            }
        }
        return right;
    }
}

5 寻找旋转排序数组中的最小值–LeetCode153（Medium）

假设按照升序排序的数组在预先未知的某个点上进行了旋转，例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2]，请找出其中最小的元素。你可以假设数组中不存在重复元素。

示例 1:

输入: [3,4,5,1,2]
输出: 1

示例 2:

输入: [4,5,6,7,0,1,2]
输出: 0

思路：
首先判断left和right位置处的元素大小，若nums[left] < nums[right]表示没有发生旋转，直接返回第一个位置处的元素。

然后使用二分法查找最小值，这里我对left和right的含义在定义上有所不同，我让left始终指向前半段（以最小值为分界点分为两部分，最小值以及后面的为后半段），right始终指向后半段，最后left和right相邻的时候退出循环，并返回right位置处的元素。

为什么返回right位置处的元素呢？
因为right始终指向后半段，范围不断收缩，最终指向最小的元素。

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

参考资料：对这道题的细节，边界条件，左中右指针分析较为透彻的一篇题解：二分查找：为什么左右不对称？只比较mid与right的原因（C++, Java, Python3）

6 在排序数组中查找元素的第一个和最后一个位置–LeetCode34（Medium）

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。你的算法时间复杂度必须是 O(log n)级别。如果数组中不存在目标值，返回 [-1, -1]。

示例 1:

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

示例 2:

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

思路：先找出target的第一个位置，判断第一个位置是否存在，判断标准是循环退出的位置的元素是否等于target，不相等的话则说明不存在。即下面的代码：

if (nums[right] != target) {
    return -1;
}

然后找出target的最后一个位置。

【注意】按此思路写出来的代码如果不注意可能会存在一个问题：提交超时。为什么会超时，因为在寻找最后一个位置的时候会陷入死循环，具体的例子参照x的平方根--LeetCode69里面的示例。解决方法就是在取中点的时候选择右中位数。

代码如下：

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] res = {-1, -1};
        if (nums.length == 0) {
            return res;
        }
        int firstPosition = findFirstPosition(nums, target);
        if(firstPosition == -1) {
            return res;
        }
        res[0] = firstPosition;
        res[1] = findLastPosition(nums, target);
        return res;
    }
    private int findFirstPosition(int[] nums, int target) {
        int left = 0, right = nums.length-1;
        while (left < right) {
            int mid = left + (right-left)/2;
            if (nums[mid] < target) {
                left = mid+1;
            }else {
                right = mid;
            }
        }
        if (nums[right] != target) {
            return -1;
        }
        return right;
    }
    private int findLastPosition(int[] nums, int target) {
        int left = 0, right = nums.length-1;
        while (left < right) {
            int mid = left + (right-left+1)/2;
            if (nums[mid] > target) {
                right = mid-1;
            }else {
                left = mid;
            }
        }
        return left;
    }
}

7 二分查找总结

二分查找的基本问题

例题：二分查找–LeetCode704

思路：先看中间位置的元素，如果恰好等于，则直接返回中间位置的下标，否则看中间位置元素的值 nums[mid]和 target的关系决定下一轮在哪一侧寻找目标元素。

这个思路把待查找数组分为了 3 个部分：mid所在位置，mid的左边，mid的右边。根据 mid元素与目标元素的值的大小关系，如果 nums[mid]恰好等于 target直接返回就好了，否则根据不等关系，确定下一轮搜索的区间在哪里。

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

说明：

循环条件：循环可以继续的条件是 while (left <= right)，表示当 left == right成立的时候，还有一个元素，即下标 left(right)位置的元素还没有看到，需要继续查看这个元素的值，看看是不是目标元素；
中点mid的计算：有两种计算中值 mid的方式，分别是：
- mid = (left + right) / 2
- mid = left + (right - left) / 2

left + right可能出现加法溢出，也就是说加法的结果大于整型能够表示的范围。但是 left和 right都为正数，因此 right - left不会出现加法溢出问题。所以，最好使用第二种计算法方法。在 Java 中还可以这样写

int mid = (left + right) >>> 1;

>>>表示无符号右移，它表示，在 left + right发生整型溢出的时候，高位补 0，结果依然正确。这一点是从 JDK 的源码中 Arrays.binarySearch()方法借鉴来的。

关于返回值：
- 如果在数组中找到了target，则返回target所在的位置。
- 如果没找到target，则返回-1表示错误，因为索引不可能为负数。

二分搜索的变种

在循环体里排除不存在目标元素的区间，例如在一个有重复元素的数组中查找 target 的最左位置的实现如下：

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

基本思想：根据看到的 mid位置的元素，排除掉一定不可能存在目标元素的区间，而下一轮在可能存在目标的子区间里继续查找。

具体做法

先把循环可以继续的条件写成 while (left < right)，表示退出循环的时候，[left, right]这个区间里只有一个元素，这个元素有可能就是目标元素；
写 if 和 else 语句的时候，思考当 nums[mid]满足什么性质的时候，num[mid] 不是解，进而接着判断 mid的左边有没有可能是解，mid的右边有没有可能是解；

根据 mid被分到左边区间还是右边区间，有两种边界收缩的行为：

mid被分到左边，即区间被分成 [left, mid]与[mid + 1, right]

int mid = left + (right - left) / 2;
if (check(mid)) { // check(mid) 函数是一个表达式
    // 下一轮搜索区间是 [mid + 1, right]
    left = mid + 1;
} else {
    right = mid;
}

mid被分到右边，即区间被分成 [left, mid - 1]与 [mid, right]

int mid = left + (right - left + 1) / 2;
if (check(mid)) {
    // 下一轮搜索区间是 [left, mid - 1]
    right = mid - 1;
} else {
    left = mid;
}

【注意】这里的mid取的是右中位数（即下取整），不然会出现死循环。解释：当搜索区间只有两个元素时，如果上取整，那么就永远取不到右边界，区间就无法收缩，导致死循环。一条简单的规则：在 if else 语句里面只要出现 left = mid 的时候，把取中间数行为改成上取整即可。

参考资料：liweiwei1419的二分查找问题总结

何时立秋丷

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode精选题之二分查找

文章目录LeetCode精选题之二分查找1 x的平方根--LeetCode692 寻找比目标字母大的最小字母--LeetCode7443 有序数组中的单一元素--LeetCode540（Medium）4 第一个错误的版本--LeetCode2785 寻找旋转排序数组中的最小值--LeetCode153（Medium）6 在排序数组中查找元素的第一个和最后一个位置--LeetCode34（Medium）7 二分查找总结二分查找的基本问题二分搜索的变种LeetCode精选题之二分查找参考资料：1、Cyc2
复制链接

扫一扫