【算法总结】二分查找详解+运用 (持续更新)

最新推荐文章于 2022-09-26 23:42:20 发布

Skyed.blue

最新推荐文章于 2022-09-26 23:42:20 发布

阅读量405

点赞数

分类专栏：算法总结文章标签：算法二分查找 ACM C++

本文链接：https://blog.csdn.net/Skyed_blue/article/details/103260295

版权

算法总结专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文二分查找内容有：

解读二分查找非递归代码的实现：查找值，查找左边界，查找有边界。
在数组中运用C++的二分查找函数 binary_search, lower_bound, upper_bound.
向量，集合里二分查找函数的运用。
二分查找的运用。

第一部分：

1. 非递归代码实现查找值

先看代码：

#include <iostream>
#include <algorithm>
using namespace std;

int a[5] = {1,2,3,4,5};
const int n = 5;	//表示数组长度 

int binary_search(int x)
{
	int l = 0, r = n-1;	//细节1 
	while(l <= r)	 //细节2 
	{
		int mid = l+r>>1;	 
		if(x < a[mid]) r = mid-1;	//细节3 
		else if(x > a[mid]) l = mid+1;	//细节4 
		else return mid;
	}
	return -1;
}

int main()
{
	int x;
	while(cin>>x) cout<<binary_search(x)<<endl;
	return 0;
}

首先先分析一下这段二分查找的代码：在区间[0,n-1]里查找x值，若找到则返回索引，没找到返回-1.
**细节1：**变量 l 和 r 就表示着这个搜索区间的左右边界。因此 l = 0, r = n-1.
细节2：二分查找的结束标志是查找到x值或者搜索区间为空。当 l == r 时，[l,r]的搜索区间依然是有效的，只有a[l]这一个值。因此当 l > r 时搜索区间才为空。故循环条件为 l <= r.
**细节3,4：**因为搜索区间是闭区间，不管什么情况下mid都会被检索到。所以我们的区间不用包括mid.

2. 非递归代码实现查找左侧边界

先看代码：

#include <iostream>
#include <algorithm>
using namespace std;

int a[5] = {1,2,2,4,5};
const int n = 5;	//表示数组长度 

int left_bound(int x)
{
	int l = 0, r = n;	//细节1
	while(l < r)	//细节2
	{
		int mid = l+r>>1;
		if(x < a[mid]) r = mid;	//细节3
		else if(x > a[mid]) l = mid+1;	//细节4
		else r = mid; //细节5
	}
	return l;	//细节6 (返回l,r均可)
} 

int main()
{
	int x;
	while(cin>>x) cout<<left_bound(x)<<endl;
	return 0;
}

首先分析一下这段代码：**在区间 [0,n) 找x的左边界(即第一个大于等于x)的索引。若x大于区间最大值，则返回数组长度。**输入0,1,2,3,4,5,6 得到的结果是 0,0,1,3,3,4,5.
**细节1：**搜索区间是[1,n) 因此 l = 1, r = n.
**细节2：**l == r 时，搜索区间 [l,l) 是空区间，因此判断条件是 l < r .
**细节3,4：**因为搜索区间是[ l,r) 左开右闭，r = mid之后搜索区间是 [l,mid) 没包括到mid，因此 r = mid. 左边为闭区间，因此 l = mid+1.
**细节5：**若查找到了该值，先不返回。我们需要查该值的左边界，因此令 r = mid 逐渐将区间往左逼近。
**细节6：**当 l == r 时，循环推出，返回该值左边界索引。

3. 非递归代码实现右边界

先看代码：

#include <iostream>
#include <algorithm>
using namespace std;

int a[5] = {1,2,2,4,5};
const int n = 5;	//表示数组长度 

int right_bound(int x)
{
	int l = 0, r = n;	//细节1
	while(l < r)	//细节2
	{
		int mid = l+r>>1;
		if(x < a[mid]) r = mid;	//细节3
		else if(x > a[mid]) l = mid+1;	//细节4
		else l = mid+1;	//细节5 (就此处与lower_bound不同)
	}
	return r;	//细节6 (返回l,r均可)
} 

int main()
{
	int x;
	while(cin>>x) cout<<right_bound(x)<<endl;
	return 0;
}

首先分析一下这段代码：**在区间 [0,n) 找x的右边界(即第一个大于x)的索引。若x大于或等于区间最大值，则返回数组长度。**输入0,1,2,3,4,5,6 得到的结果是 0,1,3,3,4,5,5.
细节1,2,3,4,6同上。
**细节5：**当查找到x值时，将区间向右逼近。又因为左区间为闭区间，因此 l = mid+1.

总结：

l, r 就是二分查找的搜索区间。
while(…)的终止条件是当搜索区间为空时才退出。
搜索值是闭区间，搜索左右边界是左闭右开区间。
左边界函数中，搜到x值时，r = mid 将区间向左逼近；右边界函数 l = mid+1 将区间向右逼近。

第二部分：

二分查找函数 binary_search, lower_bound, upper_bound的头文件：algorithm. 这三个函数只能在有序序列中使用，默认为递增序列。
先解释一下这三个函数：
· bool binary_search(t1,t2,x)：在迭代器 [t1,t2) 里查找x值，若找到则返回true，没找到返回false.
· iterator lower_bound(t1,t2,x)：在迭代器 [t1,t2) 里查找x值左边界(即第一个大于等于x)的迭代器。若x大于区间最大值，则返回end迭代器。
· int upper_bound(t1,t2,x)：在迭代器 [t1,t2) 里查找x值右边界(即第一个大于x)的迭代器。若x大于等于区间最大值，则返回end迭代器。
上代码：

#include <iostream>
#include <algorithm>
using namespace std;

int a[5] = {1,2,2,4,5};
const int n = 5;	//表示数组长度 

int main()
{
	int x;
	cout<<"原数组："<<endl;
	for(int i = 0;i < 5;i++)
	cout<<a[i]<<" ";
	cout<<"数组长度："<<n<<endl;
	while(cin>>x)
	{
		if(binary_search(a,a+n,x)) cout<<"查找：true"<<endl;
		else cout<<"查找：false"<<endl;
		cout<<"lower_bound："<<lower_bound(a,a+n,x)-a<<endl;
		cout<<"upper_bound："<<upper_bound(a,a+n,x)-a<<endl; 
	} 
	return 0;
}

代码分析：里面的 (a,a+n)就是表示迭代器。因为lower_bound和upper_bound返回的是迭代器，因此lower_bound/upper_bound - a 就代表着索引。
结果如下图：
在这里插入图片描述
其实lower_bound和upper_bound对应的就是第一部分的left_bound和right_bound，区别就是第一部分直接返回索引值，这一部分需要减去起始迭代器才表示索引值。

第三部分：

lower_bound和upper_bound在向量里的运用方式：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int a[5] = {1,2,2,4,5};
const int n = 5;	//表示数组长度 
vector<int> arr(n);

int main()
{
	int x;
	cout<<"原数组："<<endl;
	for(int i = 0;i < n;i++)
	arr[i] = a[i], cout<<arr[i]<<" ";
	cout<<"数组长度："<<n<<endl;
	while(cin>>x)
	{
		if(binary_search(arr.begin(),arr.end(),x)) cout<<"查找：true"<<endl;
		else cout<<"查找：false"<<endl;
		cout<<"lower_bound："<<lower_bound(arr.begin(),arr.end(),x)-arr.begin()<<endl;
		cout<<"upper_bound："<<upper_bound(arr.begin(),arr.end(),x)-arr.begin()<<endl; 
	} 
	return 0;
}

lower_bound和upper_bound在集合里的表示方式：

#include <iostream>
#include <set>
#include <algorithm>
using namespace std;

int a[5] = {1,2,2,4,5};
const int n = 5;	//表示数组长度 
multiset<int> st;

int main()
{
	int x;
	cout<<"原数组："<<endl;
	for(int i = 0;i < n;i++)
	st.insert(a[i]), cout<<a[i]<<" ";
	cout<<"数组长度："<<n<<endl;
	while(cin>>x)
	{
		cout<<"查找："<<distance(st.begin(),st.find(x))<<endl;
		cout<<"lower_bound："<<distance(st.begin(),st.lower_bound(x))<<endl;
		cout<<"upper_bound："<<distance(st.begin(),st.upper_bound(x))<<endl; 
	} 
	return 0;
}

在这里插入图片描述
解释一下：集合数据结构是红黑树，不能直接像数组和向量那样减去初始迭代器获得索引，而是需要通过一个函数——distance来操作。distance是用于计算两个迭代器之间的距离，从起始迭代器开始到目标迭代器。如果顺序错了会死循环。同时，binary_search也将其替换成find，可以直接返回目标值对应的迭代器。运用集合主要是看重其插入和删除都在O(lgn)，如果遇到需要同时进行多次数组元素的改变和多次询问，用multiset无疑效率高很多。

第四部分：

二分查找的特点是在有序数组的情况下查询一个数的位置，左边界，右边界时间复杂度都是O(lgn). 根据其特点运用二分查找：

题目暗示或明示数组不要求定序
比如说，在5,1,3,2,6中求5的逆序对，即右边比5小的元素。如果直接扫描5后面的所有元素时间复杂度就是O(n)，如果求整一个数组的逆序对就是O(n^2). 这个时间复杂度在许多到题都是直接TLE的。那么，改进一下。*对5后面的元素排序：1,2,3,6.我们可以直接在这个排序数组里查找小于5的个数，即查找第一个大于等于5的索引，即lower_bound(5) = 3. 因此5的逆序对就是3. 这个时间复杂度就是O(lgn)，求整个数组的逆序对时间复杂度就是O(nlgn).
求一个数的左/右边界，排序数组中比某个数小/大的元素的个数
一般不会直接要你求某个数的左/右边界，而是当成一个技巧使用。想到用nlgn的时间复杂度，题目条件明示暗示数组又不要求定序或者数组已排序就可以往这方向想。二分查找就是看题解的时候才能想到这tm也能用二分做…
在有序数组中寻找某个数满足xxx条件（二分枚举）
这种题型一般都要枚举某个范围的数一个一个试。如果线性枚举，可能会TLE. 这时候就要考虑二分枚举。如果这个数所在的集合是否是有序的，可以采用O(lgn)的二分枚举。

下面介绍一些我做过的二分查找的题。

Subsequence
给一个正整数序列，求区间和大于等于S的最小区间长度。
递增三元组
有三个数组A，B，C，每个数组中有n个数，你可以从每个数组中找一个数，使得Ai<Bj<Ck ,(1<=I,j,k<=n)(1<=n<=100000,1<=Ai,Bj,Ck<=1000000)，求最多可以组出多少三元组。
逆序对
求逆序对个数。传统方法是归并排序，我们也可以用二分。我用了multiset，因为需要一直对后面的数插空排序，所以选用了维持升序并且插入时间复杂度为O(lgn)的数据结构----红黑树multiset. 时间复杂度也为O(nlgn)

#include <bits/stdc++.h>
using namespace std;

multiset<long long> st;

int cal(int x)
{
	return distance(st.begin(), st.lower_bound(x));	//返回集合中比x小的个数
}

int main()
{
	int n;
	long long a[1010];
	while(cin>>n)
	{
		
		st.clear();
		long long ans = 0;
		for(int i = 0;i < n;i++)
		scanf("%lld", &a[i]);
		if(n == 1)
		{
			cout<<1<<endl;
			continue;
		}
		st.insert(a[n-1]);
		for(int i = n-2;i >= 0;i--)
		{
			ans += cal(a[i]);
			st.insert(a[i]);
		}
		cout<<ans<<endl;
	}
}

丑数III
丑数是可以被 a 或 b 或 c 整除的正整数，找第n个整数。
二分枚举+容斥定理。
使结果不超过阈值的最小除数
比较裸的二分枚举。
sweet Problem
不那么容易发现的二分枚举。当然本意是找规律。
Can you solve this equation?
二分查找到小数点后x位，算是一种技巧吧。
计算右侧小于当前元素的个数
归并排序或者二分，比较巧妙
使数组严格递增 (dp+二分)
区间和的个数
典型的前缀和+二分解决区间问题
有序矩阵第k小元素
分割数组的最大值
很巧妙的二分枚举，这里复制一下当时做这道题的评论：
个人想法二分枚举的框架是: 设 y = 子数组各自和的最大值, x = 划分数. x 是正整数并且和 y 是单调递减, 符合二分的有序性. 然后x的取值范围是[1,nums.size], x=1 和 x = nums.size 对应的 y 值就是 l 和 r, 即对应的枚举范围. 通过 l , r 算出 mid. 然后, 现在已知条件就是 m, mid. mid的含义就是y值域里的一个值, 设为 y’. 我们要求出题目所需的y, m就是y所对应的x值. 我们可以通过y’ 求出 x’, 即cnt. 然后通过比较 x 和 x’ 的关系确定 y 和 y’ 的关系缩小区间. 比如: m<cnt -> y>y’ -> l = mid+1. 又因为一个x可能对应多个y值, 即一个x对应一个y集合, 我们需要求出y集合中最小的值, 那么 m=cnt 时, r = mid 区间向左逼近. 循环结束后, l 就是最终结果.
【蓝桥杯】分巧克力(二分枚举)

后面遇到一些二分查找的题也会在此更新作为题料，感受二分算法的巧妙！

Skyed.blue

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【算法总结】二分查找详解+运用 (持续更新)

本文二分查找内容有：解读二分查找非递归代码的实现：查找值，查找左边界，查找有边界。在数组中运用C++的二分查找函数 binary_search, lower_bound, upper_bound.向量，集合里二分查找函数的运用。二分查找的运用。第一部分：1. 非递归代码实现查找值先看代码：#include <iostream>#include <algori...
复制链接

扫一扫