数据结构与算法随笔之------二分查找（一文彻底搞懂二分）
一.二分法的基础内容
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
本文会介绍二分查找的基础内容以及最重要的在实际应用时二分法的各种变种及其套路，相信你看了本文，二分应该就ok了
查找过程
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
算法要求
1.必须采用顺序存储结构。
2.必须按关键字大小有序排列。
算法复杂度
二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x,算法中止；如果x
时间复杂度无非就是while循环的次数！
总共有n个元素，
渐渐跟下去就是n,n/2,n/4,....n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数
由于你n/2^k取整后>=1
即令n/2^k=1
可得k=log2n,（是以2为底，n的对数）
所以时间复杂度可以表示O(h)=O(log2n)
折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。它的基本思想是：（这里假设数组元素呈升序排列）将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止；如 果x
二分伪码
（迭代法）二分查找递增有序链表L中的特定值X
{
当左边界点low不大于右边界点high时
{
取中间点mid；
如果 X等于位于中间点mid的值
返回 位置mid；
再如果 X大于位于中间点mid的值
左边界点更改为mid右边的一个点；
再如果 X小于位于中间点mid的值
右边界点更改为mid左边的一个点；
}
返回 未找到
}最好情况下：
时间复杂度：T(n)=O(1)
空间复杂度：S(n)=O(1)
最坏情况下：
时间复杂度：T(n)=O(log(n))
空间复杂度：S(n)=O(1)
使用迭代法的二分查找，辅助空间是常数级别的，所以空间复杂度始终为O(1)；最好情况下是一次能找到待查找值，所以时间复杂度是O(1)，最坏情况下，是一直查找（例如待查找值是小于左边界的一个值），每次查找会排除一半的数据，所以根据计算，时间复杂度为O(log(n))。
二分算法实现:
/**
* 二分查找，找到该值在数组中的下标，否则为-1
*/
static int binarySerach(int[] array, int key) {
int left = 0;
int right = array.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] == key) {
return mid;
}
else if (array[mid] < key) {
left = mid + 1;
}
else {
right = mid - 1;
}
}
return -1;
}每次移动left和right指针的时候，需要在mid的基础上+1或者-1， 防止出现死循环， 程序也就能够正确的运行。
注意：代码中的判断条件必须是while (left <= right)，否则的话判断条件不完整，比如：array[3] = {1, 3, 5};待查找的键为5，此时在(low < high)条件下就会找不到，因为low和high相等时，指向元素5，但是此时条件不成立，没有进入while()中。
但是这里有一个问题，就是（left+right）/2可能会产生整数溢出的问题。所以最好将其改成mid=low+(high-low)/2;
（问题会出现在当low+high的结果大于表达式结果类型所能表示的最大值时，
这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)
不存在这个问题*/
几种循环的实现方法如下：
循环实现 [2]
第一种
int BinSearch(SeqList *R，int n,KeyType K)
{
//在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回-1
int low=0,high=n-1,mid； //置当前查找区间上、下界的初值
while(low<=high)
{
if(R[low].key==K)
return low;
if(R[high].key==k)
return high; //当前查找区间R[low..high]非空
mid=low+(high-low)/2;
/*使用(low+high)/2会有整数溢出的问题
（问题会出现在当low+high的结果大于表达式结果类型所能表示的最大值时，
这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)
不存在这个问题*/
if(R[mid].key==K)
return mid; //查找成功返回
if(R[mid].keyhigh)
return -1;//当low>high时表示所查找区间内没有结果，查找失败
}
第二种
int bsearchWithoutRecursion(int array[],int low,int high,int target)
{
while(low<=high)
{
int mid=low+(high-low)/2;//还是溢出问题
if(array[mid]>target)
high=mid-1;
else if(array[mid]Array[mid]) left=mid+1;
}
return -1;
} 当然还有一种递归的方法，也很好理解，这里不细说，具体实现方法如下
#include
using namespace std;
int a[100]={1,2,3,5,12,12,12,15,29,55};//数组中的数（由小到大）
int k;//要找的数字
int found(int x,int y)
{
int m=x+(y-x)/2;
if(x>y)//查找完毕没有找到答案，返回-1
return -1;
else
{
if(a[m]==k)
return m;//找到!返回位置.
else if(a[m]>k)
return found(x,m-1);//找左边
else
return found(m+1,y);//找右边
}
}
int main()
{
cin>>k;//输入要找的数字c语言把cin换为scanf即可
cout<
二.二分查找的各种变种
这里参考了一位大佬的博客，并对他的博客进行了补充：https://www.cnblogs.com/luoxn28/p/5767571.html
关于二分查找，如果条件稍微变换一下，比如：数组之中的数据可能可以重复，要求返回匹配的数据的最小（或最大）的下标；更近一步， 需要找出数组中第一个大于key的元素（也就是最小的大于key的元素的）下标，等等。 这些，虽然只有一点点的变化，实现的时候确实要更加的细心。
二分查找的变种和二分查找原理一样，主要就是变换判断条件（也就是边界条件），如果想直接看如何记忆这些变种的窍门，请直接翻到本文最后。下面来看几种二分查找变种的代码：
2.1 查找第一个与key相等的元素
查找第一个相等的元素，也就是说等于查找key值的元素有好多个，返回这些元素最左边的元素下标。
// 查找第一个相等的元素
static int findFirstEqual(int[] array, int key) {
int left = 0;
int right = array.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] >= key) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
if (left < array.length && array[left] == key) {
return left;
}
return -1;
}
2.2 查找最后一个与key相等的元素
查找最后一个相等的元素，也就是说等于查找key值的元素有好多个，返回这些元素最右边的元素下标。
// 查找最后一个相等的元素
static int findLastEqual(int[] array, int key) {
int left = 0;
int right = array.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] <= key) {
left = mid + 1;
}
else {
right = mid - 1;
}
}
if (right >= 0 && array[right] == key) {
return right;
}
return -1;
}
2.3 查找最后一个等于或者小于key的元素
查找最后一个等于或者小于key的元素，也就是说等于查找key值的元素有好多个，返回这些元素最右边的元素下标；如果没有等于key值的元素，则返回小于key的最右边元素下标。
// 查找最后一个等于或者小于key的元素
static int findLastEqualSmaller(int[] array, int key) {
int left = 0;
int right = array.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] > key) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
return right;
}
2.4 查找最后一个小于key的元素
查找最后一个小于key的元素，也就是说返回小于key的最右边元素下标。
// 查找最后一个小于key的元素
static int findLastSmaller(int[] array, int key) {
int left = 0;
int right = array.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] >= key) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
return right;
}
2.5 查找第一个等于或者大于key的元素
查找第一个等于或者大于key的元素，也就是说等于查找key值的元素有好多个，返回这些元素最左边的元素下标；如果没有等于key值的元素，则返回大于key的最左边元素下标。
// 查找第一个等于或者大于key的元素
static int findFirstEqualLarger(int[] array, int key) {
int left = 0;
int right = array.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] >= key) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
return left;
}
2.6 查找第一个大于key的元素
查找第一个等于key的元素，也就是说返回大于key的最左边元素下标。
// 查找第一个大于key的元素
static int findFirstLarger(int[] array, int key) {
int left = 0;
int right = array.length - 1;
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] > key) {
right = mid - 1;
}
else {
left = mid + 1;
}
}
return left;
}
3 二分查找变种总结
//套路代码
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] ? key) {
//... right = mid - 1;
}
else {
// ... left = mid + 1;
}
}
return xxx;
二分查找变种较多，不过它们的“套路”是一样的，以上代码就是其套路，如何快速写出二分查找的代码，只需按照以下步骤即可：
1 首先判断出是返回left，还是返回right
方法：如果是找第一个，则返回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 判断出比较符号
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] ? key) {
//... right = mid - 1;
}
else {
// ... left = mid + 1;
}
}
return xxx;
如果查找小于等于，则使用>=,如果查找大于等于，则使用<=
也就是这里的 if (array[mid] ? key) 中的判断符号，结合步骤1和给出的条件，如果是查找小于等于key的元素，则知道应该使用判断符号>=，因为是要返回left，所以如果array[mid]等于或者大于key，就应该使用>=，以下是完整代码
// 查找小于等于key的元素
int mid = (left + right) / 2;
if (array[mid] >= key) {
right = mid - 1;
}
else {
left = mid + 1;
}