这篇博客一共记录了8道二分查找算法的题目，分别是：二分查找，在排序数组中查找元素的第一个和最后一个位置，x的平方根，搜索插入位置，山峰数组的峰顶索引，寻找峰值，寻找旋转排序数组中给的最小值，点名。
class Solution {
public:
int search(vector<int>& nums, int target)
{
int left = 0,right = nums.size()-1;
while(left <= right)
{
//int mid = (left + right)/2; //溢出风险
int mid = left + (right - left)/2;
if(nums[mid] > target) right = mid-1;
else if(nums[mid] < target) left = mid+1;
else return mid;
}
return -1;
}
};题目分析：首先，我们会想到暴力解法，也就是从左往右依次比较并返回结果，这样查找的时间复杂度无疑是O(N)。但是我们还没有利用到数组有序的特性，现在我们想对暴力解法做出改进，如果从这个数组中随机选取中间一个值x，如果x>target，那么那么x右边就不用找了，直接去x左边用一样的方法找就行；相反，如果x<target，那么x左边就不用找了，直接去x右边用一样的方法找就行；如果x==target，那么找到了，直接结束。这就是二分查找。随机找一个x，相当于把数组分成两段，这就是“二段性（根据某种规律把数组分成两部分，然后有选择性舍去一部分，在另一个部分继续查找）”，其实，只要数组有二段性，我们就可以使用二分查找！具体来说，假设目标值是t，刚开始时，我们让left和right指向数组两端，数组中间值为x（下标为mid），1.如果x<t，把x左边区间舍去，left=mid+1，right不变-->[mid+1,right] 2.如果x>t，把x右边区间舍去，right=mid-1，left不变-->[left,mid-1] 3.如果x=t，则直接返回mid。其实，这是一个循环，那么循环结束的条件是什么呢？当left==right时，还需要看这个位置是不是符合条件，因此，循环结束的条件是left>right。
那么，为什么二分查找为什么是正确的呢？我们知道暴力枚举是一次舍弃一个值，在剩下的区间查找，而二分查找是一次舍去一个区间，当然也是正确的！由于一次舍去一半的区间，所以时间复杂度是O(logN)。
在确定left和right中间位置坐标的时候，如果通过(left+right)/2来确定可能会面临溢出风险，所以，可以通过left+(right-left)/2的方法来确定！
这道题我们用的是朴素二分模版：
while(left <= right) //1.注意是<=
{
int mid = left + (right - left)/2; //2.这样可以防止溢出
if(...)
left = mid + 1;
else if(...)
right = mid - 1;
else
return ...;
}
class Solution {
public:
vector<int> searchRange(vector<int>& nums, int target)
{
//处理边界情况，nums为空
if(nums.size() == 0) return {-1,-1};
vector<int> ret;
int left = 0,right = nums.size()-1;
//1.二分左端点
while(left < right)
{
int mid = left + (right - left)/2;
//落在右侧区间
if(nums[mid] >= target) right = mid;
//落在左侧区间
else left = mid+1;
}
//判断是否有结果
if(nums[left] == target) ret.push_back(left);
else return {-1,-1};
//2.二分右端点
//左端点不用重置，因为此时left就指向右区间端点
right = nums.size()-1;
while(left < right)
{
int mid = left + (right - left +1)/2;
if(nums[mid] <= target) left = mid;
else right = mid - 1;
}
//有左端点一定就有右端点
ret.push_back(right);
return ret;
}
};题目分析：首先我们想到的是暴力解法，就是从左往右遍历一遍，先找到左端点，然后继续往后遍历，找到右端点，但是这样的做法时间复杂度是O(N)，肯定超时了。但是，我们没有利用数组非递减这个特性。那我们再来想一下，可以使用上题的朴素二分查找吗，朴素二分查找是用来一个值，如果用来查找一个区间，那么其时间复杂度就会降到O(N)。我们再来一种二分查找--查找区间的左端点，其实，我们可以将区间分为 <target 和 >=target 两个区间（二段性），我们给出一个一般数组：
- 如果 x < target，说明mid落在左区间，mid及其左侧区间肯定不包含左端点，直接让left=mid+1;
- 如果 x >= target，说明mid落在右区间，mid有可能是区间左端点，有可能是左端点右面的值，不能让right=mid-1，因为有可能mid就是左端点，所以，直接让right = mid；（这一步是和朴素二分查找的区别）
除了这个主体逻辑外，我们还需要处理两个细节：
1.循环条件
循环条件应该是left<=right还是left<right呢？
1）如果是left<=right，那么nums有三种情况：nums中有结果、nums中全部大于target、nums中全部小于target。
如果nums中有结果，经过上面步骤后，left会向结果靠近，同时，right也会在右区间不断向结果靠近，当left=right时，说明它们此时指向的就是待求结果。
如果nums全部大于target，那么只会中步骤2，只会导致right向左移动，left不动，当left=right后，只需判断这是不是待求结果即可。
如果nums全部小于target，那么只会中步骤1，只会导致left向右移动，right不动，当left=right后，只需判断这是不是待求结果即可。
综上，第一条理由，left=right的时候，就是最终结果，无需作为循环条件。
第二条理由，如果left=right被作为循环条件判断了，就会死循环。
第二条理由具体如下：如果nums中有结果，且最后只剩下一个元素，left和right指向同一个元素，如果中了步骤2，right=mid，right依旧是这个值，陷入了死循环，这是致命的一条理由！
2.求中点的操作
求中点的操作无非就是两种，一种是mid=left+(right-left)/2，另一种是mid=left+(right-left+1)/2。如果元素有偶数个，对于前者，求的是中间靠左的元素；对于后者，求的是中间靠右的元素。对于查找区间左端点，如果还剩最后两个元素，如果是用后者求中点，那么mid就是后一个元素，恰好中了步骤2，那么right=mid，就陷入了死循环，求出的mid一直是right；如果用前者求中点，那么mid就是前一个元素，无论中了步骤1和步骤2，都不会陷入死循环。
在学会了求区间左端点后，查找求区间右端点就变得很容易。我们可以将区间分为 >target 和 <=target 两个区间（二段性），我们给出一个一般数组：
- 如果 x <= target，说明mid落在左区间，mid有可能是区间右端点，有可能是区间右端点左边的值，不能让left=mid+1，因为有可能mid就是右端点，所以，直接让left=mid;（这一步是和朴素二分查找的区别）
- 如果 x > target，说明mid落在右区间，mid及其右侧区间肯定不包含右端点，直接让left=mid-1;
同样，需要处理两个细节：
1.循环条件
和上面求区间左端点理由一样，循环条件是left<right。
2.求中点的操作
和上面分析的类似，求中点的操作是mid=left+(right-left+1)/2。
现在我们来总结一下二分模版：
class Solution {
public:
int mySqrt(int x)
{
//处理边界情况
if(x < 1) return 0;
int left = 1,right = x;
while(left < right)
{
long long mid = left + (right-left+1)/2; //下一句mid*mid太大，所以mid设为long long
if(mid * mid > x) right = mid - 1;
else left = mid;
}
return left;
}
};题目分析：首先我们会想到暴力解法，从1开始依次求这个数的平方，如果当前数的平方等于x，或者当前数的平方小于x，且下一个数的平方大于x，都返回当前数。但是，考虑到我们要求的数组可以有二段性，假设ret是所求值，划分为两个区间，ret的平方≤x和ret的平方＞x，那么就可以使用上面所讲的二分查找：1. left=1，right=x（因为x可能是1，所以right为x）2.mid = left + (right-mid+1)/2 如果mid*mid>x，那么mid落在右边区间，right=mid-1，如果mid*mid <= x，mid落在左边区间，left=mid。
class Solution {
public:
int searchInsert(vector<int>& nums, int target)
{
if(nums[nums.size()-1] < target) return nums.size();
int left = 0,right = nums.size()-1;
while(left < right)
{
int mid = left + (right - left)/2;
if(nums[mid] < target) left = mid + 1;
else right = mid;
}
return left;
}
};题目分析：这道题明显看出来要用二分查找，有两种情况，第一种是直接在数组里找到了target，第二种情况是没找到target，但是找到了比target大的第一个值，无论哪种情况，我们只需返回找到值的下标即可。我们可以将数组分为两段，左边区间<target，右边区间≥target，我们需要找到右边区间的第一个值的下标。1.mid=left+(right-left)/2 2.如果nums[mid]<target，说明mid落在了左边区间，left=mid+1；如果nums[mid]≥target，说明mid落在了右边区间，right=mid。
class Solution {
public:
int peakIndexInMountainArray(vector<int>& arr)
{
int left = 1,right = arr.size()-2;//最两边的肯定不是山峰，没必要查找
while(left < right)
{
int mid = left + (right - left + 1)/2;
if(arr[mid] > arr[mid -1]) left = mid;
else right = mid - 1;
}
return left;
}
};代码分析：首先我们会想到暴力求解，从前往后开始找，如果当前值大于前一个值，说明还在左山峰上，继续这样查找，直到发现当前值小于前一个值，这样前一个值就是山峰值，但是，这样的时间复杂度为O(N)，。我们再来观察，可以将山峰数组分为两部分，一部分是递增的，一部分是递减的，因此具有二段性，可以考虑使用二分查找方法。当arr[mid]>arr[mid-1]时，left=mid，当arr[mid]<arr[mid-1]时，right=mid-1。
class Solution {
public:
int findPeakElement(vector<int>& nums)
{
int left = 0,right = nums.size()-1;
while(left < right)
{
int mid = left + (right - left)/2;
if(nums[mid] > nums[mid + 1]) right = mid;
else left = mid + 1;
}
return left;
}
};题目分析：我们这道题首先想到暴力解法，从左往右遍历数组，总共三种情况，1）如果nums[0]>nums[1]，由于nums[-1]=负无穷，nums[0]就是峰值元素；2）在中间出现nums[i-1]<nums[i]<nums[i+1]，nums[i]就是峰值元素；3）数组元素一直递增，由于nums[n]=负无穷，nums[n-1]就是峰值元素。
接下来就是优化解法，我们在数组中间随便找两个值nums[i]和nums[i+1]，如果nums[i]>nums[i+1]，由于nums[-1]=-无穷，所以在nums[i]及其左边肯定存在峰值，nums[i]的右边不一定存在峰值，所以，这样数组就存在二段性；如果nums[i]<nums[i+1]，由于nums[n]=-无穷，所以nums[i+1]及其右边肯定存在峰值，nums[i+1]的左边则不一定存在峰值，这样数组也存在二段性，所以，我们就可以使用二分查找算法。1.left=0，right=nums。size-1 2.如果nums[mid]>nums[mid+1]，right=mid；如果nums[mid]<nums[mid+1]，left=mid+1。
class Solution {
public:
int findMin(vector<int>& nums)
{
int left = 0, right = nums.size() - 1;
while(left < right)
{
int mid = left + (right - left) / 2;
if(nums[mid] > nums[nums.size() - 1]) left = mid + 1;
else right = mid;
}
return nums[left];
}
};
题目分析：我们可以将数组分成两个区间，左边区间AB中的值全部大于nums[n-1]，右边区间CD中的值全部小于等于nums[n-1]，因此具有二段性，可以采用二分查找算法，1.left = 0，right = n-1 2.当nums[mid]>nums[n-1]，mid位于AB区间，left=mid+1;当nums[mid]<=nums[n-1]，mid位于CD区间，right=mid。
class Solution {
public:
int takeAttendance(vector<int>& records)
{
int left = 0, right = records.size() - 1;
while(left < right)
{
int mid = left + (right - left) / 2;
if(records[mid] == mid) left = mid + 1;
else right = mid;
}
if(records[records.size() - 1] == (records.size() - 1)) return records.size();
return left;
}
};题目分析：这道题有很多种解法，也是面试中面试官非常青睐的题目，可以考察面试者的知识深度。
第一种就是利用哈希表的方式解决，将元素逐个插入哈希表，最后看哪个位置对应的值为0，就是缺失的元素。
第二种就是直接遍历找结果。
第三种就是用数学方式解决，利用求和公式计算出0-n-1的和，然后减去数组中各个元素，剩下的就是缺失的元素。
第四种就是通过位运算的方式解决，0 1 2 3 4 5 6 和 0 1 2 3 5 6全部异或起来的之后就是4。
但是这四种方法的时间复杂度都是O(N)，接下来利用二分查找算法把时间复杂度降为O(logN)。
第五种就是二分查找算法，我们看一个例子，如果给的数组是0 1 2 3 5 6，那么它们的下标分别是0 1 2 3 4 5，我们发现前4个数的值和其下标一样，后两个数和其下标差1，因此，这个数组就具有二段性，我们要求的值就是右区间左端值的下标，就可以使用二分算法求解。1.left = 0，right = size-1 2.如果nums[mid] == mid，那就落在了左边区间，left = mid + 1；如果nums[mid] != mid，就落在了右区间，right = mid。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
