数据结构->二分查找
二分法的思想十分容易理解，但还是很多人对二分感到很苦恼，很困惑，可能是因为 二分的边界 很难掌握，也许是判断条件难写…
二分法细节确实比较多，但是真正理解之后，是可以有一个通用模板的，根本不需要考虑到底是开区间还是闭区间，加一还是减一还是不加减，更不需要打补丁。
✨ 二分查找
🏬小故事：
小明和冰冰在玩猜数字的游戏；
游戏规则：在1~100中，冰冰随便想一个数字，让小明来猜，游戏开始啦！
假设小明从1开始依次往上猜，猜测过程会是这样：
（这是简单查找，更准确的说法是傻找。每次猜测都只能排除一个数字。如果冰冰想的数字是 99，小明得猜 99次 才能猜到！）
于是另一种更佳的猜法。小明直接从 50 开始猜。
小了，但排除了一半的数字！至此，小明知道1～50都小了。接下来，小明猜 75。
大了，那余下的数字又排除了一半！使用二分查找时，小明猜测的是中间的数字，从而每次都将余下的数字排除一半。接下来，小明猜 63（50和75中间的数字）。
这就是二分查找，小明学习了第一种算法！每次猜测排除的数字个数如下
不管冰冰心里想的是哪个数字，小明在 7 次之内都能猜到，因为每次猜测都将排除很多数字！
🤔思考：
假设你要在字典中查找一个单词，而该字典包含 240000 个单词，你认为每种查找最多需要多少步？
如果要查找的单词位于字典末尾，使用简单查找将需要 240000 步。使用二分查找时，每次排除一半单词，直到最后只剩下一个单词。
因此，使用二分查找只需 18 步——少多了！一般而言，对于包含n个元素的列表，用二分查找最多需要 log₂n 步，而简单查找最多需要 n 步。
✨ 总结二分
我自己总结了会运用到 二分查找 的几种情况，
我们先假设数组是升序排列，再给你一个数target。
如下图：
🐱🐉思路：进阶版一和进阶版二应该尽量用同一种方法解决，而不需要考虑太多不一样的细节。而在我的思路中，进阶版一二三四都是同一个套路，Don’t Blink
🎊 基础版
首先你需要知道最基础版应该怎么写，二分法的思想其实很简单，就是先取中间的数，然后和target比较，如果小了就往右找，大了就往左找。然后再取中间数，如此循环，直到中间没有数了。
思路我相信大家都能理解，但是在写法上，实际上还有一个 双指针 的思想，也就是我们需要left和right两个指针，然后不断调整两个指针的位置，最终得到答案。
下面我们通过一个例子来帮助我们理解。
我们需要在 nums 数组中，查询元素 8 的索引
（1）我们需要定义两个指针分别指向数组的头部及尾部，这是我们在整个数组中查询的情况，当我们在数组某一区间进行查询时，可以输入数组，起始位置，终止位置进行查询。
（2）找出mid，该索引为mid =（left + right）/ 2，但是这样写有可能溢出，所以我们需要改进一下写成mid = left +（right - left）/ 2 或者 left + ((right - left ) >> 1) 两者作用是一样的，都是为了找到两指针的中间索引，使用位运算的速度更快。那么此时的 mid = 0 + (8-0) / 2 = 4
（3）此时我们的
mid = 4，nums[mid] = 6 < target,那么我们需要移动我们的 left 指针，让left = mid + 1，下次则可以在新的 left 和 right 区间内搜索目标值，下图为移动前和移动后：
（4）我们需要在left和right之间计算mid值，mid = 5 + （8 - 5）/ 2 = 6然后将nums[mid]与target继续比较，进而决定下次移动 left 指针还是 right 指针，见下图：
（5）我们发现
nums[mid] > target，则需要移动我们的 right 指针， 则right = mid - 1；则移动过后我们的 left 和 right 会重合，这里是我们的一个重点大家需要注意一下，后面会对此做详细叙述。
（6）我们需要在left和right之间继续计算mid值，则mid = 5 +（5 - 5）/ 2 = 5，见下图，此时我们将nums[mid]和target比较，则发现 两值相 等， 返回mid即可 ， 如果不相等则跳出循环，返回 -1 。
二分查找的执行过程如下：
1.从已经排好序的数组或区间中，取出中间位置的元素，将其与我们的目标值进行比较，判断是否相等，如果相等则返回。
2.如果 nums[mid] 和 target 不相等，则对 nums[mid] 和 target 值进行比较大小，通过比较结果决定是从 mid的左半部分还是右半部分继续搜索。
如果 target > nums[mid] 则右半区间继续进行搜索，即left = mid + 1; 若target < nums[mid]则在左半区间继续进行搜索，即 right = mid -1；
🐱💻动图解析：
📄代码示例
废话不多说，我们看一下代码
int binarySearch(int *nums, int sz, int target)
{
int left = 0;//左下标
int right = sz - 1;//右下标
while (left <= right)
{
//计算mid
int mid = left + ((right - left) >> 1);
if (nums[mid] == target) {
return mid;
}
else if (nums[mid] < target) {
//移动左下标
left = mid + 1;
}
else {
//移动右下标
right = mid - 1;
}
}
//没有找到该元素，返回-1
return -1;
}
int main()
{
int target = 8;//我们要查找的数字
int nums[] = { 1,3,4,5,6,8,12,14,16 };
int sz = sizeof(nums) / sizeof(nums[0]);
int ret = binarySearch(nums, sz, target);
if (-1 == ret) {
printf("nums数组中不存在traget\n");
} else {
printf("找到了,下标是%d,数字是%d\n", ret, target);
}
return 0;
}
运行结果：
🐱🚀解析：
我相信大家可能看过其他版本，比如所谓的开区间版本，但是我告诉大家，没有必要去看去记这么多版本，你只要会一种就能解万题！！！，而我建议大家就写上面这种。
这种也叫闭区间版本，每一个数都会搜索到，需要注意的几个点
1、right初始是sz-1，很好理解，因为这是数组右边界下标
2、while里面是left <= right，也好理解，因为我们每个数都要搜索，当left = right时，我们当然要进里面再判断一下
3、区间范围缩小时，left=mid+1或者right=mid-1，也好理解，因为nums[mid]已经不是我们要找的数，所以范围需要加一或者减一
二分查找的思路及代码已经理解了，那么我们来看一下实现时容易出错的地方
1、计算 mid 时 ，不能使用 （left + right ）/ 2,否则有可能会导致溢出
2、while (left < = right) 注意括号内为left <= right ,而不是 left < right ；
我们继续回顾刚才的例子，如果我们设置条件为 left < right 则当我们执行到最后一步时，则我们的 left 和 right 重叠时，则会跳出循环，返回 -1，区间内不存在该元素，但其实不是这样的！
我们的 left 和 right 此时指向的就是我们的目标元素 ，但是此时 left = right 跳出循环（因为我们的while循环条件是：left < right）
3、left = mid + 1, right = mid - 1 而不是 left = mid 和 right = mid。
我们思考一下这种情况，见下图：当我们的 target 元素为 16 时，然后我们此时 left = 7 ，right = 8，mid = left + (right - left) = 7 + (8-7) = 7，那如果设置 left = mid 的话，则会进入死循环，mid 值一直为7 。
之所以要推荐闭区间版本，是因为它最符合我们的直观逻辑，而且它是对称的，是把left和right一视同仁，而不会像有的版本left需要加一，但是right却不需要减一。
🎊 进阶版一
有了基础版，那么如何在基础版的代码上进行升级呢？
先来看问题：
找到等于target的左边界（数组中可能有多个数都等于target），找不到返回-1
说实话，如果是第一次碰到这个问题，还真不一定能找到最优解！
第一个直观感受可能是我找到mid后，在往左一个一个地看，看看哪里是边界，但是这样，时间复杂度可能退化成o(n)！
其实还是应该用二分的思想找，关键在于nums[mid] == target时候的处理。
📄代码示例
int binarySearch(int* nums, int sz, int target)
{
int left = 0;//左下标
int right = sz - 1;//右下标
int flag = -1;
while (left <= right)
{
//计算mid
int mid = left + ((right - left) >> 1);
if (nums[mid] == target) {
flag = mid;
right = mid - 1;
}
else if (nums[mid] < target) {
//移动左下标
left = mid + 1;
}
else {
//移动右下标
right = mid - 1;
}
}
//没有找到该元素，返回-1
return flag;
}
🤔解析：
这里的一个技巧就是当arr[mid] == target时，因为要找左边界，我们把right=mid-1，也就是改变右边界从而缩小范围。
这时候其实存在两种情况，要么答案已经是flag(左边界)，[left,right]里面已经没有答案，while再也不会更新flag，最终返回flag是正确的，
要么flag还不是最终答案，那么答案就会在[left,right]里面，而在while中，我们总能找到它从而更新flag，最终返回flag也是正确的。
这里我们额外定义了一个flag表示结果，这一步是整个解法的精髓。相对于很多其他教程在考虑到底是返回left还是left+1还是right还是right-1，直接定义一个flag要好理解得多。
🙋这里也要注意几点：
1、flag一定是符合条件的，比如在这里，我们只有当arr[mid] == target的时候，我们才会更新flag。
2、flag会随着搜索范围减小越来越接近答案，当搜索结束时，flag就是答案。
3、如果一次都没有更新flag，说明整个数组里没有满足条件的数，flag应该为-1，也就是初始值。
🎊 进阶版二
先看问题：
找到等于target的右边界（数组中可能有多个数都等于target），找不到返回-1
理解了上面的进阶版一，我相信这个问题都不需要我解释，直接看代码就行，
📄代码示例
int binarySearch(int* nums, int sz, int target)
{
int left = 0;//左下标
int right = sz - 1;//右下标
int flag = -1;
while (left <= right)
{
//计算mid
int mid = left + ((right - left) >> 1);
if (nums[mid] == target) {
flag = mid;
left = mid + 1;
}
else if (nums[mid] < target) {
//移动左下标
left = mid + 1;
}
else {
//移动右下标
right = mid - 1;
}
}
//没有找到该元素，返回-1
return flag;
}
同样，在进阶版三和进阶版四中，只需要考虑什么时候更新flag；
🎊 进阶版三
先看问题：
找到小于target的最大值，找不到返回-1
因为要找的数是小于target的，所以应该在arr[mid] < target时更新flag；
📄代码示例
int binarySearch(int* nums, int sz, int target)
{
int left = 0;
int right = sz - 1;
int flag = -1;
while (left <= right)
{
int mid = left + ((right - left) >> 1);
if (nums[mid] < target) {
flag = mid;
left = mid + 1;
}
else {
right = mid - 1;
}
}
return flag;
}
🎊 进阶版四
先看问题：
找到大于target的最小值，找不到返回-1
因为要找的数是大于target的，所以应该在arr[mid] > target时更新flag；
📄代码示例
int binarySearch(int* nums, int sz, int target)
{
int left = 0;
int right = sz - 1;
int flag = -1;
while (left <= right)
{
int mid = left + ((right - left) >> 1);
if (nums[mid] < target) {
left = mid + 1;
}
else {
flag = mid;
right = mid - 1;
}
}
return flag;
}
🐱🏍 推荐例题
光看不练，岂不是白给吗？下面这几道题个别还是有点难度，仔细理解，干就完事了！
📄例题一：leetcode35. 搜索插入位置
📄例题二：leetcode34. 在排序数组中查找元素的第一个和最后一个位置
📄例题三：leetcode33. 搜索旋转排序数组
📄例题四：leetcode81. 搜索旋转排序数组 II
📄例题五：leetcode153. 寻找旋转排序数组中的最小值
🎃 结语
像有些文章还介绍了：第一种写法、第二种写法、什么左闭右闭、左闭右开…