[C/C++]二分查找专题/最后一个小于等于目标值target的数/第一个大于等于目标值target的数

二分查找基础

查找有序数组中
（1）某一个数
（2）最后一个小于目标值target的数
（3）最后一个小于等于目标值target的数
（3）第一个大于目标值target的数
（5）第一个大于等于目标值target的数
采用二分查找，返回该数的索引，没有的话返回-10(non_exit)

小知识点：
（1）int mid = (l + r) / 2 和 int mid=l+(r-l)/2;的区别？
int mid = (l + r) / 2 中 (l + r)可能出现整数溢出，这就导致计算结果不是正确的中位数。

代码：
（1）查找某一个数

//二分查找某个数
int binarySearchOne(vector<int> vec, int target)
{
	int l = 0, r = vec.size() - 1;
	while (l <= r)
	{
		int mid=l+(r-l)/2;
		if (vec[mid] == target)  //关键点
			return mid;
		if (vec[mid] > target)
		{
			r = mid - 1;
		}
		else {
			l = mid + 1;
		}
	}
	return non_exit;
}

（2）查找最后一个小于目标值target的数

//二分查找最后一个小于某个数
int binarySearchFirstLess(vector<int> vec, int target)
{
	int l = 0, r = vec.size() - 1;
	while (l <= r)
	{
		int mid=l+(r-l)/2;
		if (vec[mid] >= target)  //关键点，>=
		{
			r = mid - 1;
		}
		else {
			l = mid + 1;
		}
	}
	if(r<0)     //区分索引越界，即没找到
		return non_exit;
	return r;
}

（3）查找最后一个小于等于目标值target的数，即右边界

//二分查找最后一个小于等于某个数,若相等则返回最右边的
int binarySearchFirstLessEqual(vector<int> vec, int target) 
{
	int l = 0, r = vec.size() - 1;
	while (l <= r)
	{
		int mid=l+(r-l)/2;
		if (vec[mid] > target)  //关键点,>
		{
			r = mid - 1;
		}
		else {
			l = mid + 1;
		}
	}
	if (r < 0)  //如果要找的是最后一个等于target的位置，则条件是 if(r<0 || vec[r]!=target)
		return non_exit;
	return r;
}

分析：

1. 对于题目（2）小于、题目（3）小于等于，代码不同的在于关键点处：
   题目（2）小于：则将大于等于分为一类。
   题目（3）小于等于：则将大于分为一类。
2. 最后返回 $r$，也即对应了题设中“最后一个”。

（4）查找第一个大于目标值target的数

//二分查找第一个大于某个数
int binarySearchFirstGreater(vector<int> vec, int target)
{
	int l = 0, r = vec.size() - 1;
	while (l <= r)
	{
		int mid=l+(r-l)/2;
		if (vec[mid] <= target)  //关键点,<=
		{
			l = mid + 1; 
		}
		else {
			r = mid - 1;
		}
	}
	if (l >= vec.size())      //区分索引越界，即没找到
		return non_exit;
	return l;
}

（5）查找第一个大于等于目标值target的数，即左边界

//二分查找第一个大于等于某个数,若相等则返回最左边的
int binarySearchFirstGreaterEqual(vector<int> vec, int target)
{
	int l = 0, r = vec.size() - 1;
	while (l <= r)
	{
		int mid=l+(r-l)/2;
		if (vec[mid] < target)  //关键点,<
		{
			l = mid + 1;
		}
		else {
			r = mid - 1;
		}
	}
	if (l >= vec.size())    //如果要找的是第一个等于target的位置，则条件是 if(l >= vec.size() || vec[l]!=target)
		return non_exit;
	return l;
}

分析：

1. 对于题目（4）大于、题目（5）大于等于，代码不同的在于关键点处：
   题目（4）大于：则将小于等于分为一类。
   题目（5）大于等于：则将小于分为一类。
2. 最后返回 $l$，也即对应了题设中“第一个”。

（6）主函数，测试

#include<iostream>
#include<vector>
#include<algorithm>


using namespace std;

vector<int> nums{ 1,3,3,4,5,6,7,7,9,10 };  //有序数组

//不存在标志，不要设为-1，因为有时候没找到返回的刚好是-1，可能让你忘记去区分最后的索引是否越界
const int non_exit = -10;     

//主函数，测试
int main()
{
	//测试（1）
	int a1 = binarySearchOne(nums, 3);                       //输入存在的，返回对应索引，1
	int a2 = binarySearchOne(nums, 11);                      //输入不存在的，返回non_exit
	 
	 //测试（2）
	int b1 = binarySearchFirstLess(nums, 3);                //输入存在的，返回对应索引,0
	int b2 = binarySearchFirstLess(nums, 1);                //输入左边界，返回non_exit
	int b3 = binarySearchFirstLess(nums,11);                //输入右边界外的，返回9
	
	//测试（3）
	int c1 = binarySearchFirstLessEqual(nums, 3);           //输入存在的，返回对应索引,2
	int c2 = binarySearchFirstLessEqual(nums, 1);           //输入左边界，返回0
	int c3 = binarySearchFirstLessEqual(nums, 0);           //输入左边界外的，返回non_exit
	int c4 = binarySearchFirstLessEqual(nums, 10);          //输入右边界，返回对应索引,9
	
	//测试（4）
	int d1 = binarySearchFirstGreater(nums, 3);             //输入存在的，返回对应索引,3
	int d2 = binarySearchFirstGreater(nums, -1);            //输入左边界外的，返回0
	int d3 = binarySearchFirstGreater(nums, 10);            //输入右边界，返回non_exit
	
	//测试（5）
	int e1 = binarySearchFirstGreaterEqual(nums, 3);        //输入存在的，返回对应索引,1
	int e2 = binarySearchFirstGreaterEqual(nums, 1);        //输入左边界，返回0
	int e3 = binarySearchFirstGreaterEqual(nums, 10);       //输入右边界，返回size-1,9
	int e4 = binarySearchFirstGreaterEqual(nums, 11);       //输入右边界外的，返回non_exit

	return 0;
}

总结：
5套代码框架基本一样，关键点处不同。

习题1：给定非负整数k，问有多少个n使n!后面有k个0。

给你一个非负整数k，问有多少个n使n!后面有k个0。
思路：
（1）设计函数$f1$，计算阶乘后0的数目。
（2）寻找 k 的右边界 right 。即最后一个小于等于目标值k的数，使用上一节中的函数（3）。但是，我们要判断返回的值是否刚好为k，若不是，则等于不成立。
（3）寻找 k 的左边界 left 。即第一个大于等于目标值k的数，使用上一节中的函数（5）。同样，我们要判断返回的值是否刚好为k，若不是，则等于不成立。
（4）对于上下界所使用的的函数，我需要好好想一想，比如序列 [ 1, 2, 3, 3, 4, 5 ]，给定目标值3，右边界 right 是用 “最后一个<=3” 这样的概念找出来的， 左边界 left 是使用 “第一个大于等于3” 这样的概念找出来的。
（5）对于等于号都成立的，返回 right - left +1 。对于等于号都不成立的，返回 0 。

代码：

#include<iostream>
using namespace std;

const int non_exist = -10;

//计算某个数的阶乘后面有多少个0
long trailingZeros(long n)
{
	long res = 0;
	while (n)
	{
		res += n / 5;
		n /= 5;
	}
	return res;
}

//二分查找右边界：最后一个trailingZeros(n)<=k
long firstLessEqual(long k)
{
	long l = 0, r = LONG_MAX;
	while (l<=r)
	{
		long mid = l + (r - l) / 2;
		if (trailingZeros(mid) > k)
		{
			r = mid - 1; 
		}
		else {
			l = mid + 1;
		}
	}

	//检测边界是否是等于
	if (trailingZeros(r)!=k)
		return non_exist;
	return r;
}



//二分查找左边界：第一个trailingZeros(n)>=k
long firstGreaterEqual(long k)
{
	long l = 0, r = LONG_MAX;
	while (l <= r)
	{
		long mid = l + (r - l) / 2;
		if (trailingZeros(mid) < k)
		{
			l = mid + 1; 
		}
		else 
		{
			r = mid - 1;
		}
	}
	//检测边界是否是等于
	if (trailingZeros(l) != k)
		return non_exist;
	return l;
}


int main()
{
	long k = 6, count=0;
	long right = firstLessEqual(k);
	long left = firstGreaterEqual(k);
	if(left!=non_exist && right!=non_exist )
		count = right - left +1;
	return 0;
}

习题：
消失男孩：[LeetCode][C++]搜索旋转排序数组 I/ II