二分查找
文章目录
源代码链接: https://github.com/lankuohsing/LeetCode-Java/tree/master/LeetCodeInJava/src/binary_search
1.二分查找的一般场景(查找升序数组target值区域的左边界)
给定一个 n
个元素有序的(升序)整型数组 nums
和一个目标值 target
,返回target
在nums
中的下标;如果目标值不存在,则返回-1;如果目标值存在多个,则返回最左边那个。
核心代码:
public int findLeftIndex(int nums[], int target) {
// 循环继续的条件:start <= end
// 更新start的条件:nums[middle] < target
// 如果target不存在,最终start为第一个大于target的下标(如果没有大于target的,就等于nums.length)
// 如果target存在,最终start为最左边那个下标
if (nums.length == 0) {
return -1;
}
int start = 0;
int end = nums.length - 1, middle;
while (start <= end) {
middle = start + (end - start) / 2;//防止溢出
if (nums[middle] < target) {
start = middle + 1;
} else {
end = middle - 1;
}
}
int left = start;
System.out.println("原始的left:" + left);
if (left == nums.length || nums[left] != target) {
left = -1;
}
return left;
}
解释:
· 两个哨兵(start和end)分别从数组最左端和最右端开始往中间逼进,每次逼近都是用middle+1更新start或者用middle-1更新start,其中middle = (start + end) / 2(这也就是二分查找的来历,也叫对半查找)。
· 循环继续的条件为start≤end。
· 更新start的条件为nums[middle] < target,更新end的条件为前面条件的else情况(所以如果存在一个或多个target,都会更新middle)
· 当循环跳出时,一定有start>end。为什么不在nums[middle]==target的时候退出循环?因为如果有多个target的话,nums[middle]==target无法保证是最左边那个target。
当退出循环后,一定有start==end+1.此时的nums[start]有两种情况:
- nums[start]==target,且nums[start]是最左边的那个target
- start == nums.length(越界了),此时说明数组里面所有元素都小于target
- nums[start] != target,说明target不存在(但是target的值确实在数组区间内)
因此上面的代码在返回前有如下代码来决定返回值(返回值记为left):
int left = start;
System.out.println("原始的left:" + left);
if (left == nums.length || nums[left] != target) {
left = -1;
}
return left;
完整代码见package:find_left_right_index
2.二分查找的简单场景-升序不重复数组查找指定元素
leetcode 704. 二分查找
给定一个 n
个元素有序的(升序)整型数组 nums
和一个目标值 target
,写一个函数搜索 nums
中的 target
,如果目标值存在返回下标,否则返回 -1
。假设 nums
中的所有元素是不重复的。
因为数组元素不重复,因此可以提前剪枝(nums[middle]==target时直接返回)。同时,可以省去循环后面后续判断,因为如果是等到循环正常结束的话一定是元素不存在,因此可以直接在循环结束后返回-1.
public int search(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
int result = -1;
while (left <= right) {// 注意是小于等于
int middle = left + (right - left) / 2;
if (nums[middle] == target) {
result = middle;
break;
} else {
if (target < nums[middle]) {
right = middle - 1;// 注意要减1
} else {
left = middle + 1;// 注意要加1
}
}
}
return result;
}
3.二分查找思想的高阶应用(持续更新中)
3.1. 二分查找的一般场景(查找升序数组target值区域的右边界)
给定一个 n
个元素有序的(升序)整型数组 nums
和一个目标值 target
,返回target
在nums
中的下标;如果目标值不存在,则返回-1;如果目标值存在多个,则返回最右边那个。
public int findRightIndex(int nums[], int target) {
// 循环继续的条件:start <= end
// 更新start的条件:nums[middle] <= target
// 如果target不存在,最终start为第一个大于target的下标(如果没有大于target的,就等于nums.length)
// 如果target存在,最终start为最右边那个下标+1
if (nums.length == 0) {
return -1;
}
int start = 0;
int end = nums.length - 1, middle;
while (start <= end) {
middle = start + (end - start) / 2;
if (nums[middle] <= target) {
start = middle + 1;
} else {
end = middle - 1;
}
}
int right = start;
System.out.println("原始的right:" + right);
if (right == nums.length) {
if (nums[right - 1] != target) {
right = -1;
}
} else {
if (right - 1 < 0 || nums[right - 1] != target) {
right = -1;
}
}
return right == -1 ? right : right - 1;
}
3.2. 升序数组中统计目标值出现的次数
剑指 Offer 53 - I. 在排序数组中查找数字 I
统计一个数字在排序数组中出现的次数。注意,虽然这里说的是排序数组,但是测试数据都是升序数组,所以我们的代码也按照升序数组来处理。严格意义上,应该先判断是否为升序还是降序,然后做一些微小的改变
class Solution {
public int search(int[] nums, int target) {
int left = findLeftIndex(nums,target);
int right = findRightIndex(nums,target);
if(left==-1||right==-1){
return 0;
} else{
return right-left+1;
}
}
public int findLeftIndex(int nums[], int target) {
// 循环继续的条件:start <= end
// 更新start的条件:nums[middle] < target
// 如果target不存在,最终start为第一个大于target的下标(如果没有大于target的,就等于nums.length)
// 如果target存在,最终start为最左边那个下标
if (nums.length == 0) {
return -1;
}
int start = 0;
int end = nums.length - 1, middle;
while (start <= end) {
middle = (start + end) / 2;
if (nums[middle] < target) {
start = middle + 1;
} else {
end = middle - 1;
}
}
int left = start;
if (left == nums.length || nums[left] != target) {
left = -1;
}
return left;
}
public int findRightIndex(int nums[], int target) {
// 循环继续的条件:start <= end
// 更新start的条件:nums[middle] <= target
// 如果target不存在,最终start为第一个大于target的下标(如果没有大于target的,就等于nums.length)
// 如果target存在,最终start为最右边那个下标
if (nums.length == 0) {
return -1;
}
int start = 0;
int end = nums.length - 1, middle;
while (start <= end) {
middle = (start + end) / 2;
if (nums[middle] <= target) {
start = middle + 1;
} else {
end = middle - 1;
}
}
int right = start;
if (right == nums.length) {
if (nums[right - 1] != target) {
right = -1;
}
} else {
if (right - 1 < 0 || nums[right - 1] != target) {
right = -1;
}
}
return right == -1 ? right : right - 1;//
}
}
3.3. 魔术索引(简单情形)
魔术索引。 在数组A[0…n-1]中,有所谓的魔术索引,满足条件A[i] = i。
给定一个有序整数数组,编写一种方法找出魔术索引,若有的话,在数组A中找出一个魔术索引,如果没有,则返回-1。
若有多个魔术索引,返回索引值最小的一个。
这里考虑简单情形,即数组中没有重复元素(严格单调递增数组)
public class Solution {
public int findMagicIndex(int[] nums) {
int left = 0;
int right = nums.length - 1;
while (left <= right) {
int middle = left + (right - left) / 2;
if (nums[middle] >= middle) {
right = middle - 1;
} else {
left = middle + 1;
}
}
if (left == nums.length || nums[left] != left) {
left = -1;
}
return left;
}
}
3.4. 魔术索引(复杂情形情形)
魔术索引。 在数组A[0…n-1]中,有所谓的魔术索引,满足条件A[i] = i。
给定一个有序整数数组,编写一种方法找出魔术索引,若有的话,在数组A中找出一个魔术索引,如果没有,则返回-1。
若有多个魔术索引,返回索引值最小的一个。
这里考虑复杂情形,即数组中可能有重复元素
public class Solution {
public int findMagicIndex(int[] nums) {
return getAnswer(nums, 0, nums.length - 1);
}
int getAnswer(int[] nums, int left, int right) {
if (left > right) {
return -1;
}
int middle = left + (right - left) / 2;
int answer = getAnswer(nums, left, middle - 1);
if (answer != -1) {
return answer;
} else {
if (middle == nums[middle]) {
return middle;
}
}
return getAnswer(nums, middle + 1, right);
}
}