------
二分查找基本版及其各种变形的汇总
思想: 二分搜索的核心就是**循环结束条件**和**左右边界迭代规则**
#### 一. 基本二分
##### 基本的二分查找
我们这个算法中使用的是前者 `[left, right]` 两端都闭的区间。**这个区间其实就是每次进行搜索的区间**
当然，找到了目标值的时候可以终止
if(nums[mid] == target)
return mid;
```java
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 if (nums[mid] > target) {
right = mid - 1;
} else if(nums[mid] == target) {
// 直接返回
return mid;
}
}
// 直接返回
return -1;
}
```
#### 二. 进阶二分
##### 2.1 寻找左侧边界的二分查找
```java
int leftBound(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 if (nums[mid] > target) {
right = mid - 1;
} else if (nums[mid] == target) {
// 别返回，锁定左侧边界
right = mid - 1;
}
}
// 最后要检查 left 越界的情况
if (left >= nums.length || nums[left] != target)
return -1;
return left;
}
```
##### 2.2 寻找右侧边界的二分查找
```java
int rightBound(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 if (nums[mid] > target) {
right = mid - 1;
} else if (nums[mid] == target) {
// 别返回，锁定右侧边界
left = mid + 1;
}
}
// 最后要检查 right 越界的情况
if (right < 0 || nums[right] != target)
return -1;
return right;
}
```
注意点：**注意搜索区间 和 while的终止条件**
##### 2.3 查找最后一个等于或者小于target的元素
关键词：**右边界**
查找最后一个等于或者小于target的元素，也就是说如果查找target值的元素有好多个，返回这些元素最右边的元素下标；如果没有等于target值的元素，则返回小于target的最右边元素下标
```java
// 查找最后一个等于或者小于target的元素
int findLastEqualSmaller(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] > target) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
return right; //必须返回right
}
```
##### 2.4 查找最后一个小于target的元素
返回小于target的最右边元素下标
```java
// 查找最后一个小于target的元素
int findLastSmaller(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] >= target) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
return right; //必须返回right
}
```
##### 2.5 查找第一个等于或者大于target的元素
关键词：左边界
查找第一个等于或者大于target 的元素，也就是说如果查找target值的元素有好多个，返回这些元素最左边的元素下标；如果没有等于target值的元素，则返回大于target的最左边元素下标
```java
// 查找第一个等于或者大于key的元素
int findFirstEqualLarger(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] >= target) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
return left;
}
```
##### 2.6 查找第一个大于target的元素
```java
// 查找第一个大于key的元素
int findFirstLarger(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] > target) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
return left;
}
```
第一个大于等于target 或者 最后一个小于等于target的元素，扩展开来，
最小条件: **第一个满足条件的** ，左边界
**案例一：阿珂吃香蕉**：找到第一个满足条件的，比 该值大的都满足，所以是找左边界
满足条件指的是：canFinish(piles, mid, H)
https://leetcode-cn.com/problems/koko-eating-bananas/
```java
public int minEatingSpeed(int[] piles, int H) {
int maxSpeed = getMax(piles);
int left= 1;
int right = maxSpeed;
while(left <= right){
int mid= left +(right -left)/2;
if(canFinish(piles, mid, H)){ //查找左边界，找到第一个满足 条件的
right = mid-1;
} else {
left = mid + 1;
}
}
return left;
}
// 时间复杂度 O(N)
boolean canFinish(int[] piles, int speed, int H) {
int time = 0;
for (int n : piles) {
time += timeOf(n, speed);
}
return time <= H;
}
int timeOf(int n, int speed) {
return (n / speed) + ((n % speed > 0) ? 1 : 0);
}
int getMax(int[] piles) {
int max = 0;
for (int n : piles)
max = Math.max(n, max);
return max;
}
```
案例二： 给定一个包含 n + 1 个整数的数组 nums， 找出重复数
满足条件： cnt[i] > i;
```java
public int findDuplicate_BinarySearch(int[] nums) {
int n = nums.length;
int l =1, r = n-1;
while(l <=r ){
int mid = l + (r -l)/2;
int cnt = cntLessEqual(nums, mid);
if(cnt > mid){// 查找第一个满足条件的 ：cnt[mid] > mid的最左边
r = mid -1;
} else {
l = mid +1;
}
}
return l;
}
private int cntLessEqual(int[] nums, int target){
int cnt = 0;
for(int n:nums){
if(n <= target){
cnt++;
}
}
return cnt;
}
```
#### 三. 二分查找变种总结
```java
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] ? key) {
//... right = mid - 1;
}
else {
// ... left = mid + 1;
}
}
return xxx;
```
1. 首先判断出是返回left，还是返回right
因为我们知道最后跳出while (left <= right)循环条件是right < left，且right = left - 1。最后right和left一定是卡在"边界值"的左右两边，如果是比较值为key，查找小于等于（或者是小于）key的元素，则边界值就是等于key的所有元素的最左边那个，其实应该返回left。
以数组{1, 2, 3, 3, 4, 5}为例，如果需要查找第一个等于或者小于3的元素下标，我们比较的key值是3，则最后left和right需要满足以下条件：
我们比较的key值是3，所以此时我们需要返回left
2. 判断出比较符号
```java
int mid = (left + right) / 2;
if (array[mid] ? key) {
//... right = xxx;
}
else {
// ... left = xxx;
}
```
也就是这里的 if (array[mid] ? key) 中的判断符号，结合步骤1和给出的条件，如果是查找小于等于key的元素，则知道应该使用判断符号>=，因为是要返回left，所以如果array[mid]等于或者大于key，就应该使用>=，以下是完整代码
```java
// 查找小于等于key的元素
int mid = (left + right) / 2;
if (array[mid] >= key) {
right = mid - 1;
}
else {
left = mid + 1;
}
```
### 另类二叉查找
https://leetcode-cn.com/problems/find-peak-element/
寻找峰值
峰值元素是指其值大于左右相邻值的元素。
给定一个输入数组 nums，其中 nums[i] ≠ nums[i+1]，找到峰值元素并返回其索引。
数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞
```java
public int findPeakElement(int[] nums) {
int l = 0, r = nums.length - 1;
while (l < r) {
int mid = l + (r -l)/2;
if (nums[mid] > nums[mid + 1])
r = mid;
else
l = mid + 1;
}
return l;
}
```
参考：
https://labuladong.gitbook.io/algo/suan-fa-si-wei-xi-lie/er-fen-cha-zhao-xiang-jie
https://blog.csdn.net/bat67/article/details/72049104