二分查找模板
左边界
首先我们要根据查找元素，正好将数组分成两个部分，并且目标元素是右边区间的左边界：
此时left和right围成待搜索区间，此时mid有两种可能：
- 要么落在左区间：
我们知道左区间的值势必不会是target，因此搜索区间可以变成[mid+1,right]：
- mid还可能落在右区间：
但mid有可能是target，所以搜索区间变成[left,mid]。
wait！此时mid都找到了target，为什么不直接返回结果呢？
回到开头，我们是将数组化成左右两个区间，target是右区间左边界。但实际上我们仅知道如此了，并不能明确这个数是不是target。所以只能继续搜寻，直到left和right重合，我们才能确定指向的是右区间的左边界。
此时我们需要注意mid取值时只能向下取整，不能向上取整，来看一种边界情况：
此时仅剩下两元素，很明显right就是结果。但是如果用向上取整，mid就会指向right，搜索区间就变成[left,mid]=[left,right]。也就是进入死循环了，但如果向下取整，搜索区间就变成[mid+1,right]=[right,right]我们就找到了结果.
总的来说模板就是：
cpp
int BinarySearchLeftBoundary(vector<int>&nums)
{
int left=0,right=nums.size()-1,mid=0;
while(left<right)
{
//防止整型越界
mid=left+(right-left)/2;
if(nums[mid]属于左区间)
left=mid+1;
else
right=mid;
}
return left;
}有边界
即目标元素在左区间的右边界。
此时mid落在左区间是有可能是target的，而右区间则不可能。
因此相对的，mid要用向上取整：
cpp
int BinarySearchRightBoundary(vector<int>&nums)
{
int left=0,right=nums.size()-1,mid=0;
while(left<right)
{
//防止整型越界
mid=left+(right-left+1)/2;//区别1
if(nums[mid]属于左区间)
left=mid;//区别2
else
right=mid-1;//区别3
}
return left;
}山脉数组的峰顶索引
题目描述
给定一个长度为 n 的整数 山脉 数组 arr ，其中的值递增到一个 峰值元素 然后递减。
返回峰值元素的下标。
你必须设计并实现时间复杂度为 O(log(n)) 的解决方案。
示例 1：
输入：arr = [0,1,0]
输出：1
示例 2：
输入：arr = [0,2,1,0]
输出：1
示例 3：
输入：arr = [0,10,5,2]
输出：1
提示：
- 3 <= arr.length <= 105
- 0 <= arr[i] <= 106
题目数据 保证 arr 是一个山脉数组
算法原理
- 二分查找
根据前面的的分析已经很明了了，一个数组如果想要用二分查找target。主要看能不能以target为分界点将数组分成两个区间，我们来观测一下山脉数组的特点：
那么你们发现了什么。
没错！
target左边是单调递增区间，右边是单调递减区间，target则是左区间的有边界！
算法实现
cpp
class Solution {
public:
int peakIndexInMountainArray(vector<int>& arr)
{
int left = 0, right = arr.size() - 1, mid = 0;
while (left < right)
{
mid = left + (right - left + 1) / 2;
if (arr[mid] > arr[mid - 1])
left = mid;
else
right = mid - 1;
}
return left;
}
};
寻找峰值
题目描述
峰值元素是指其值严格大于左右相邻值的元素。
给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞ 。
你必须实现时间复杂度为 O(log n) 的算法来解决此问题。
示例 1：
输入：nums = [1,2,3,1]
输出：2
解释：3 是峰值元素，你的函数应该返回其索引 2。
示例 2：
输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5
解释：你的函数可以返回索引 1，其峰值元素为 2；
或者返回索引 5， 其峰值元素为 6。
提示：
- 1 <= nums.length <= 1000
- -231 <= nums[i] <= 231 - 1
- 对于所有有效的 i 都有 nums[i] != nums[i + 1]
算法原理
注意到可以假设 nums[-1] = nums[n] = -∞ ，这意味着我们的数组大概长这样：
这意味着，数组最左边永远有单调递增区间，右边永远有单调递减区间。
而根据上一题山脉数组的峰顶索引，我们知道。峰值的左边一定是递增区间、右边是递减区间。
这意味着，当mid指向递增区间时，mid右边一定有峰值；
相对的，当mid指向递减区间时，mid左边一定有峰值。
算法实现
cpp
class Solution {
public:
int findPeakElement(vector<int>& nums)
{
int left = 0, right = nums.size() - 1, mid = 0;
while (left < right)
{
mid = left + (right - left + 1) / 2;
if (nums[mid] > nums[mid - 1])
left = mid;
else
right = mid - 1;
}
return left;
}
};
寻找旋转排序数组中的最小值
题目描述
已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
示例 1：
输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
示例 2：
输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。
示例 3：
输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。
提示：
- n == nums.length
- 1 <= n <= 5000
- -5000 <= nums[i] <= 5000
- nums 中的所有整数 互不相同
- nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转
算法原理
首先我们的未旋转前的数组是一个严格单调递增的数组：
旋转后相当于有个传送门，将左边部分传送到右边部分：
do u feel insterting?
注意到我们可以划分左右区间了，左区间的值一定大于right的值，右区间的值一定小于right的值。target则是右区间的左边界。
算法实现
cpp
class Solution {
public:
int findMin(vector<int>& nums)
{
int n = nums.size() - 1;
int left = 0, right = n, mid = 0;
while (left < right)
{
mid = left + (right - left) / 2;
if (nums[mid] > nums[n])
left = mid + 1;
else
right = mid;
}
return nums[left];
}
};
点名
题目描述
某班级 n 位同学的学号为 0 ~ n-1。点名结果记录于升序数组 records。假定仅有一位同学缺席，请返回他的学号。
示例 1：
输入：records = [0,1,2,3,5]
输出：4
示例 2：
输入：records = [0, 1, 2, 3, 4, 5, 6, 8]
输出：7
提示：
- 1 <= records.length <= 10000
算法原理
现在还是要划分左右区间，我们以输入：records = [0, 1, 2, 3, 4, 5, 6, 8]为例：
好吧，我们可以发现左区间的value＝index，右区间则不相等。依次找到左区间右边界或者右区间左边界都可。
算法实现
cpp
class Solution {
public:
int takeAttendance(vector<int>& records)
{
if(records[0])
return 0;
int left = 0, right = records.size() - 1, mid = 0;
while (left < right)
{
mid = left + (right - left + 1) / 2;
if (records[mid] != mid)
right = mid - 1;
else
left = mid;
}
return left + 1;
}
};