感谢代码随想录公众号,以及「BridgeGeorge」博主
https://blog.csdn.net/ylyg050518/article/details/78825577
二分查找的思考
二分查找涉及的很多的边界条件,逻辑比较简单,但就是写不好。例如到底是 while(left < right)
还是 while(left <= right)
,到底是right = middle
呢,还是要right = middle - 1
呢?
写二分法,区间的定义一般为两种,左闭右闭即[left, right],或者左闭右开即[left, right)。
第一种写法
我们定义 target 是在一个在左闭右闭的区间里,也就是[left, right]
(这个很重要非常重要)。
区间的定义这就决定了二分法的代码应该如何写,因为定义target在[left, right]区间,所以有如下两点:
while (left <= right)
要使用<=
,因为left == right
是有意义的,所以使用<=
if (nums[middle] > target)
right
要赋值为middle - 1
,因为当前这个nums[middle]
一定不是target
,那么接下来要查找的左区间结束下标位置就是middle - 1
class Solution {
public int search(int[] nums, int target) {
// 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
if (target < nums[0] || target > nums[nums.length - 1]) {
return -1;
}
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + ((right - left) >> 1);
if (nums[mid] == target)
return mid;
else if (nums[mid] < target)
left = mid + 1;
else if (nums[mid] > target)
right = mid - 1;
}
return -1;
}
}
第二种写法
如果说定义target
是在一个在左闭右开的区间里,也就是[left, right)
,那么二分法的边界处理方式则截然不同。
有如下两点:
while (left < right)
,这里使用<
,因为left == right
在区间[left, right)是没有意义的if (nums[middle] > target)
right
更新为middle
,因为当前nums[middle]
不等于target
,去左区间继续寻找,而寻找区间是左闭右开区间,所以right
更新为middle
,即:下一个查询区间不会去比较nums[middle]
class Solution {
public int search(int[] nums, int target) {
int left = 0, right = nums.length;
while (left < right) {
int mid = left + ((right - left) >> 1);
if (nums[mid] == target)
return mid;
else if (nums[mid] < target)
left = mid + 1;
else if (nums[mid] > target)
right = mid;
}
return -1;
}
}
本文主要介绍第一种 左闭右闭的写法相关变体
二分查找变体
在基础二分查找的代码中,加入在while循环中不执行返回退出操作,判断条件做稍微改动,其实只是去掉了返回操作,只剩一个if-else判断。
//target 在左边
if (target < nums[mid])
right = mid - 1;
//target 在右边
else
left = mid + 1;
那么最终 left,right关系是 right+1=left
举个栗子,例如 nums={ 1,2,3,3,3,3,4,5 } target=3
- 当判断条件为
if (target <= nums[mid]) ... else
时,最终位置状态为
1,2(right),3(left),3,3,3, 4,5
right left的位置卡在target序列的左边界。 - 当判断条件为
if (target < nums[mid]) ... else
时,最终位置状态为1,2,3,3,3,3(right),4(left),5
right left的位置卡在target序列的右边界。
那么假如target不存在呢?比如 nums={1,2,4,5} target=3
- 当 判断条件为
if (target <= nums[mid]) ... else
时,最终位置状态为1,2(right),4(left),5 - 当判断条件为
if (target < nums[mid]) ... else
时,最终位置状态为1,2(right),4(left),5
从以上的分析中可以看到,left,right 总是停留在target元素的附近,并且还有一定的规律。
其实根据不同的条件下left,right位置信息,我们可以利用二分查找还能能解决以下6个问题:
返回第一个=target的元素位置,此时判断符号<= 要返回left;
返回第一个>=target的元素位置,此时判断符号<= 要返回left;
返回第一个>target的元素位置,此时判断符号<要返回left;
返回最后一个=target的元素位置,此时判断符号<,要返回right;
返回最后一个<=target的元素位置,此时判断符号位<,返回right;
返回最后一个< target的元素位置,此时判断符号位<=,返回right。
以上问题都可以套用如下二分查找的结构:
····
//条件必须是 <=
while (left <= right) {
mid = left + (right-left) / 2;
//target 在左半部分
if (target ➀ nums[mid])
right = mid - 1;
//target 在右边部分
else if (target > nums[mid])
left = mid + 1;
}
...
return ➁;
➀ 所在位置的比较符号要么是< 要么是<=
➁ 位置要么是 left要么是right.
下表给出六种情况下➀➁处的取值。
如何记忆
首先程序结构要按以上给出的结构来写,那么根据问题,确定出问题在哪一种种判断条件下才能取得结果,是< 还是 <= ,其次确定出 应该返回left 还是right.
比如要求 第一个大于> target的元素位置,那right left 必定卡在 target序列的右边界,此时判断条件只能是 <,并且 应该返回 left。
程序实现
下面给出所有情况的具体程序实现,实际运用时要弄懂问题要求,再按照具体情况给出不同的解答。
public class Solution {
/**
* 基础二分查找
*
* @param nums
* @param target
* @return
*/
public int binarySearch(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int mid;
//条件必须是 <=
while (left <= right) {
mid = left + (right-left) / 2;
//target 在左边
if (target > nums[mid])
right = mid - 1;
//target 在右边
else if (target < nums[mid])
left = mid + 1;
else
return mid;
}
return -1;
}
//----------以下是二分查找的6种变体情况-------------
// nums={ 1,2(right),3(left),3,3,3(right) 4(left),5 } target=3
// nums={1,2(right),4(left),5} target=3
//1. first =(left(<=)) >=(left(<=)) >(left(<))
//2. last =(right(<)) <=(right(<)) <(right(<=))
/**
* 找第一个大于target的元素位置 符号必须是<
*
* @param nums
* @param target
* @return
*/
public int findFirstGreater(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int mid;
//条件必须是 <=
while (left <= right) {
mid = left + (right-left) / 2;
//target 在左边
if (target < nums[mid])
right = mid - 1;
//target 在右边
else
left = mid + 1;
}
return left;
}
/**
* 查找第一个大于等于target的元素位置 符号是<= 保证 left有指向target的机会
*
* @param nums
* @param target
* @return
*/
public int findFirstGreaterEqual(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int mid;
//条件必须是 <=
while (left <= right) {
mid = left + (right-left) / 2;
//target 在左边 条件是 target> nums[mid]
if (target <= nums[mid])
right = mid - 1;
//target 在右边
else
left = mid + 1;
}
return left;
}
/**
* 查找第一个等于target的元素位置 符号是<=
*
* @param nums
* @param target
* @return
*/
public int findFirstEqual(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int mid;
//条件必须是 <=
while (left <= right) {
mid = left + (right-left) / 2;
//target 在左边
if (target <= nums[mid])
right = mid - 1;
//target 在右边
else
left = mid + 1;
}
//判断边界
if (left < nums.length && nums[left] == target)
return left;
return -1;
}
/**
* 查找最后一个=target的元素位置 符号是<
*
* @param nums
* @param target
* @return
*/
public int findLastEqual(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int mid;
//条件必须是 <=
while (left <= right) {
mid = left + (right-left) / 2;
//target 在左边
if (target < nums[mid])
right = mid - 1;
//target 在右边
else
left = mid + 1;
}
if (right >= 0 && nums[right] == target)
return right;
return -1;
}
/**
* 查找最后一个<target的元素位置 <=
*
* @param nums
* @param target
* @return
*/
public int findLastLess(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int mid;
//条件必须是 <=
while (left <= right) {
mid = left + (right-left) / 2;
//target 在左边
if (target <= nums[mid])
right = mid - 1;
//target 在右边
else
left = mid + 1;
}
return right;
}
/**
* 查找最后一个<=target的元素位置 <
*
* @param nums
* @param target
* @return
*/
public int findLastLessEqual(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int mid;
//条件必须是 <=
while (left <= right) {
mid = left + (right-left) / 2;
//target 在左边
if (target < nums[mid])
right = mid - 1;
//target 在右边
else
left = mid + 1;
}
return right;
}
}