有了这套模板,再不担心刷不动LeetCode了
Posted AI科技大本营
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了有了这套模板,再不担心刷不动LeetCode了相关的知识,希望对你有一定的参考价值。
《十分好用的二分查找法模板》演示文稿
1、导读
本文介绍了我这半年以来,在刷题过程中使用“二分查找法”刷题的一个模板,包括这个模板的优点、使用技巧、注意事项、调试方法等。
2、历史上有关“二分查找法”的故事
-
算法和程序设计技术的先驱 Donald Ervin Knuth(中文名:高德纳):
Although the basic idea of binary search is comparatively straightforward, the details can be surprisingly tricky …
-
同样是高德纳先生,在其著作《计算机程序设计的艺术 第 3 卷:排序和查找》中指出:
二分查找法的思想在 1946 年就被提出来了。但是第 1 个没有 Bug 的二分查找法在 1962 年才出现。
-
《编程珠玑》的作者 Jon Bentley:
When Jon Bentley assigned binary search as a problem in a course for professional programmers, he found that ninety percent failed to provide a correct solution after several hours of working on it, mainly because the incorrect implementations failed to run or returned a wrong answer in rare edge cases.
3、“传统的”二分查找法模板的问题
int mid = (left + right) / 2
left
和
right
都比较大的时候,
left + right
很有可能超过 int 类型能表示的最大值,即整型溢出,为了避免这个问题,应该写成:
int mid = left + (right - left) / 2 ;
int mid = left + (right - left) / 2
在
right
很大、
left
是负数且很小的时候,
right - left
也有可能超过
int
类型能表示的最大值,只不过一般情况下
left
和
right
表示的是数组索引值,
left
是非负数,因此
right - left
溢出的可能性很小。
int mid = (left + right) >>> 1 ;
使用“左边界索引 + 右边界索引”,然后“无符号右移 1 位”是推荐的写法。
1、如果目标值(严格)大于排序数组的最后一个数,返回这个排序数组的长度,否则进入第 2 点。 2、返回排序数组从左到右,大于或者等于目标值的第 1 个数的索引。
public class Solution3 {
public int searchInsert(int[] nums, int target) {
int len = nums.length;
if (nums[len - 1] < target) {
return len;
}
int left = 0;
int right = len - 1;
while (left <= right) {
int mid = (left + right) / 2;
// 等于的情况最简单,我们应该放在第 1 个分支进行判断
if (nums[mid] == target) {
return mid;
} else if (nums[mid] < target) {
// 题目要我们返回大于或者等于目标值的第 1 个数的索引
// 此时 mid 一定不是所求的左边界,
// 此时左边界更新为 mid + 1
left = mid + 1;
} else {
// 既然不会等于,此时 nums[mid] > target
// mid 也一定不是所求的右边界
// 此时右边界更新为 mid - 1
right = mid - 1;
}
}
// 注意:一定得返回左边界 left,
// 如果返回右边界 right 提交代码不会通过
// 【注意】下面我尝试说明一下理由,如果你不太理解下面我说的,那是我表达的问题
// 但我建议你不要纠结这个问题,因为我将要介绍的二分查找法模板,可以避免对返回 left 和 right 的讨论
// 理由是对于 [1,3,5,6],target = 2,返回大于等于 target 的第 1 个数的索引,此时应该返回 1
// 在上面的 while (left <= right) 退出循环以后,right < left,right = 0 ,left = 1
// 根据题意应该返回 left,
// 如果题目要求你返回小于等于 target 的所有数里最大的那个索引值,应该返回 right
return left;
}
}
while (left <= right)
时,在写最后一句
return
的时候,如果不假思索,把左边界
left
返回回去,虽然写对了,但可以思考一下为什么不返回右边界
right
呢?
left
是有一定道理的,如果题目换一种问法,你可能就要返回右边界
right
,这句话不太理解没有关系,我也不打算讲得很清楚(在上面代码的注释中我已经解释了原因),因为实在太绕了,这不是我要说的重点。
传统二分查找法模板,当退出 while
循环的时候,在返回左边界还是右边界这个问题上,比较容易出错。
4、“神奇的”二分查找法模板的基本思想
(1)首先把循环可以进行的条件写成 while(left < right)
,在退出循环的时候,一定有 left == right
成立,此时返回 left
或者 right
都可以
没有关系,我们就等到退出循环以后来看,甚至经过分析,有时都不用看,就能确定它是目标数值。
“排除法”即:在每一轮循环中排除一半以上的元素,于是在对数级别的时间复杂度内,就可以把区间“夹逼” 只剩下 1 个数,而这个数是不是我们要找的数,单独做一次判断就可以了。
while (left < right)
模板写法的 2 段参考代码,以下代码的细节部分在后文中会讲到,因此一些地方不太明白没有关系,暂时跳过即可。
[0, size]
。
public class Solution {
public int searchInsert(int[] nums, int target) {
# 返回大于等于 target 的索引,有可能是最后一个
int len = nums.length;
if (len == 0) {
return 0;
}
int left = 0;
# 如果 target 比 nums里所有的数都大,则最后一个数的索引 + 1 就是候选值,因此,右边界应该是数组的长度
int right = len;
# 二分的逻辑一定要写对,否则会出现死循环或者数组下标越界
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] < target) {
left = mid + 1;
} else {
right = mid;
}
}
return left;
}
}
[0, size - 1]
内使用二分查找法进行搜索。
public class Solution {
// 只会把比自己大的覆盖成小的
// 二分法
// 如果有一连串数跟 target 相同,则返回索引最靠前的
// 特例:3 5 5 5 5 5 5 5 5 5
// 特例:3 6 7 8
// System.out.println("尝试过的值:" + mid);
// 1 2 3 5 5 5 5 5 5 6 ,target = 5
// 1 2 3 3 5 5 5 6 target = 4
public int searchInsert(int[] nums, int target) {
int len = nums.length;
if (len == 0) {
return -1;
}
if (nums[len - 1] < target) {
return len;
}
int left = 0;
int right = len - 1;
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] < target) {
// nums[mid] 的值可以舍弃
left = mid + 1;
} else {
// nums[mid] 不能舍弃
right = mid;
}
}
return right;
}
public static void main(String[] args) {
int[] nums = {1, 2, 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6};
int target = 4;
Solution2 solution2 = new Solution2();
int searchInsert = solution2.searchInsert(nums, target);
System.out.println(searchInsert);
}
}
5、细节、注意事项、调试方法
(1)前提:思考左、右边界,如果左、右边界不包括目标数值,会导致错误结果
实现 int sqrt(int x)
函数。计算并返回 x 的平方根,其中 x 是非负整数。 由于返回类型是整数,结果只保留整数的部分,小数部分将被舍去。
因此左边界可以取 0 ,右边界可以取 x。
可以分析得再细一点,但这道题没有必要,因为二分查找法会帮你排除掉不符合的区间元素。
给定一个包含 n + 1 个整数的数组 nums,其数字都在 1 到 n 之间(包括 1 和 n),可知至少存在一个重复的整数。假设只有一个重复的整数,找出这个重复的数。
-
如果 left
和right
表示的是数组的索引,就要考虑“索引是否有效” ,即“索引是否越界” 是重要的定界依据; -
左右边界一定要包括目标元素,例如 LeetCode 第 35 题:“搜索插入位置” ,当 target
比数组中的最后一个数字还要大(不能等于)的时候,插入元素的位置就是数组的最后一个位置 + 1,即(len - 1 + 1 =) len
,如果忽略掉这一点,把右边界定为len - 1
,代码就不能通过在线测评。
(2)中位数先写 `int mid = (left + right) >>> 1 ;` 根据循环里分支的编写情况,再做调整
-
当数组的元素个数是偶数的时候:
int mid = left + (right - left) / 2 ;
得到左中位数的索引;
int mid = left + (right - left + 1) / 2 ;
得到右中位数的索引。
-
当数组的元素个数是奇数的时候,以上二者都能选到最中间的那个中位数。
int mid = left + (right - left) / 2 ;
int mid = (left + right) >>> 1;
int mid = left + (right - left + 1) / 2 ;
int mid = (left + right + 1) >>> 1
left = 3
,右边界索引
right = 4
的时候,
mid1 = left + (right - left) // 2 = 3 + (4 - 3) // 2 = 3 + 0 = 3
mid2 = left + (right - left + 1) // 2 = 3 + (4 - 3 + 1) // 2 = 3 + 1 = 4
mid1
是索引
left
,右中位数
mid2
是索引
right
。
(right - left)
不加 选左中位数,加 选右中位数。
(3)先写逻辑上容易想到的分支逻辑,这个分支逻辑通常是排除中位数的逻辑;
实现 int sqrt(int x)
函数。计算并返回 x 的平方根,其中 x 是非负整数。 由于返回类型是整数,结果只保留整数的部分,小数部分将被舍去。
(4)循环内只写两个分支,一个分支排除中位数,另一个分支不排除中位数,循环中不单独对中位数作判断
不用在每次循环开始单独考虑中位数是否是目标元素,节约了时间,我们只要在退出循环的时候,即左右区间压缩成一个数(索引)的时候,去判断这个索引表示的数是否是目标元素,而不必在二分的逻辑中单独做判断。
left
就至少是
mid + 1
;
mid
排除,因此右边界
right
至多是
mid
,此时右边界不向左边收缩。
(5)根据分支逻辑选择中位数的类型,可能是左中位数,也可能是右位数,选择的标准是避免死循环
1、如果分支的逻辑,在选择左边界的时候,不能排除中位数,那么中位数就选“右中位数”,只有这样区间才会收缩,否则进入死循环; 2、同理,如果分支的逻辑,在选择右边界的时候,不能排除中位数,那么中位数就选“左中位数”,只有这样区间才会收缩,否则进入死循环。
while left < right:
# 不妨先写左中位数,看看你的分支会不会让你代码出现死循环,从而调整
mid = left + (right - left) // 2
# 业务逻辑代码
if (check(mid)):
# 选择右边界的时候,可以排除中位数
right = mid - 1
else:
# 选择左边界的时候,不能排除中位数
left = mid
-
在区间中的元素只剩下 $2$ 个时候,例如: left = 3
,right = 4
。此时左中位数就是左边界,如果你的逻辑执行到left = mid
这个分支,且你选择的中位数是左中位数,此时左边界就不会得到更新,区间就不会再收缩(理解这句话是关键),从而进入死循环; -
为了避免出现死循环,你需要选择中位数是右中位数,当逻辑执行到 left = mid
这个分支的时候,因为你选择了右中位数,让逻辑可以转而执行到right = mid - 1
让区间收缩,最终成为 1 个数,退出while
循环。
(6)退出循环的时候,可能需要对“夹逼”剩下的那个数单独做一次判断,这一步称之为“后处理”。
left
或者
right
,无需再做判断;
nums[left]
或者
nums[right]
(此时
nums[left] == nums[right]
)单独作一次判断,看它是不是你要找的数即可,这一步操作常常叫做“后处理”。
-
如果你能确定候选区间里目标元素一定存在,则不必做“后处理”。
实现 int sqrt(int x)
函数。计算并返回 x 的平方根,其中 x 是非负整数。 由于返回类型是整数,结果只保留整数的部分,小数部分将被舍去。
[0, x]
内一定存在,故退出
while (left < right)
循环以后,不必单独判断
left
或者
right
是否符合题意。
-
如果你不能确定候选区间里目标元素一定存在,需要单独做一次判断。
给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。
(7)取中位数的时候,要避免在计算上出现整型溢出;
int mid = (left + right) / 2;
的问题:在
left
和
right
很大的时候,
left + right
会发生整型溢出,变成负数,这是一个 bug ,得改!
int mid = left + (right - left) / 2;
在
right
很大、
left
是负数且很小的时候,
right - left
也有可能超过 int 类型能表示的最大值,只不过一般情况下
left
和
right
表示的是数组索引值,
left
是非负数,因此
right - left
溢出的可能性很小。因此,它是正确的写法。下面介绍推荐的写法。
int mid = (left + right) >>> 1;
如果这样写
, left + right
在发生整型溢出以后,会变成负数,此时如果除以
,mid
是一个负数,但是经过无符号右移,可以得到在不溢出的情况下正确的结果。
>>>
和右移运算符
>>
的区别如下:
-
右移运算符 >>
在右移时,丢弃右边指定位数,左边补上符号位; -
无符号右移运算符 >>>
在右移时,丢弃右边指定位数,左边补上 ,也就是说,对于正数来说,二者一样,而负数通过>>>
后能变成正数。
int mid = (left + right) / 2
与
int mid = left + (right - left) / 2
两种写法都有整型溢出的风险,没有哪一个是绝对安全的,注意:这里我们取平均值用的是除以 2,并且是整除:
-
int mid = (left + right) / 2
在left
和right
都很大的时候会溢出; -
int mid = left + (right - left) / 2
在right
很大,且left
是负数且很小的时候会溢出;
left
和
right
一般都表示数组的索引,因此
left
在绝大多数情况下不会是负数并且很小,因此使用
int mid = left + (right - left) // 2
相对
int mid = (left + right) // 2
更安全一些,并且也能向别人展示我们注意到了整型溢出这种情况,但事实上,还有更好的方式;
int mid = (left + right) >>> 1
这种写法,其实是大有含义的:
JDK8 中采用 int mid = (left + right) >>> 1
,重点不在+
,而在>>>
。
left
和
high
都是整型最大值的时候,注意,此时 位整型最大值它的二进制表示的最高位是 ,它们相加以后,最高位是 ,变成负数,但是再经过无符号右移
>>>
(
重点是忽略了符号位
,空位都以 补齐),就能保证使用
+
在整型溢出了以后结果还是正确的。
Collections
和
Arrays
提供的
binarySearch
方法,我们点进去看
left
和
right
都表示索引,使用无符号右移又不怕整型溢出,那就用
int mid = (left + right) >>> 1
好啦。位运算本来就比使用除法快,这样看来使用
+
和
<<<
真的是又快又好了。
int mid = (left + right) >>> 1
吧,反正更多的时候
left
和
right
表示索引。
(8)编码一旦出现死循环,输出必要的变量值、分支逻辑是调试的重要方法。
6、总结
(1)原因:
无脑地写 while left < right:
,这样你就不用判断,在退出循环的时候你应该返回left
还是right
,因为返回left
或者right
都对;
(2)技巧:
先写分支逻辑,并且先写排除中位数的逻辑分支(因为更多时候排除中位数的逻辑容易想,但是前面我也提到过,这并不绝对),另一个分支的逻辑你就不用想了,写出第 1 个分支的反面代码即可(下面的说明中有介绍),再根据分支的情况选择使用左中位数还是右中位数;
-
如果第 1 个分支的逻辑是“左边界排除中位数”( left = mid + 1
),那么第 2 个分支的逻辑就一定是“右边界不排除中位数”(right = mid
),反过来也成立; -
如果第 2 个分支的逻辑是“右边界排除中位数”( right = mid - 1
),那么第 2 个分支的逻辑就一定是“左边界不排除中位数”(left = mid
),反之也成立。
(3)优点:
分支条数只有 2 条,代码执行效率更高,不用在每一轮循环中单独判断中位数是否符合题目要求,写分支的逻辑的目的是尽量排除更多的候选元素,而判断中位数是否符合题目要求我们放在最后进行,这就是第 5 点;
(4)注意事项1:
左中位数还是右中位数选择的标准根据分支的逻辑而来,标准是每一次循环都应该让区间收缩,当候选区间只剩下 个元素的时候,为了避免死循环发生,选择正确的中位数类型。如果你实在很晕,不防就使用有 个元素的测试用例,就能明白其中的原因,另外在代码出现死循环的时候,建议你可以将左边界、右边界、你选择的中位数的值,还有分支逻辑都打印输出一下,出现死循环的原因就一目了然了;
(5)注意事项 2:
如果能确定要找的数就在候选区间里,那么退出循环的时候,区间最后收缩成为 个数后,直接把这个数返回即可;如果你要找的数有可能不在候选区间里,区间最后收缩成为 个数后,还要单独判断一下这个数是否符合题意。
(right - left)
这个括号里面加 。
虽说是两个模板,区别在于选中位数,中位数根据分支逻辑来选,原则是区间要收缩,且不出现死循环,退出循环的时候,视情况,有可能需要对最后剩下的数单独做判断。
7、应用提升
◆
精彩推荐
◆
推荐阅读
你点的每个“在看”,我都认真当成了AI
以上是关于有了这套模板,再不担心刷不动LeetCode了的主要内容,如果未能解决你的问题,请参考以下文章
一直以为做报表只能用EXCEL和PPT,直到我看到了这套模板(附模板)
资源| 火爆Github!这套LeetCode 刷题模板也太实用了