在计算机科学中，二分搜索（英语：binary search），也称折半搜索（英语：half-interval search）[1]、对数搜索（英语：logarithmic search）[2]，是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。
二分算法作为算法考试和面试中的重点，因此对此做了一些总结。
关于二分算法的一些基本操作
1.给定一个有序（非降序）数组A，求任意一个i使得A[i]等于target，不存在则返回-1
//最朴素的二分查找。基础中的基础
int search(int A[], int n, int target)
{
int low = 0, high = n-1;
while(low <= high)
{
// 注意：若使用(low+high)/2求中间位置容易溢出
int mid = low+((high-low)>>1);
if(A[mid] == target)
return mid;
else if(A[mid] < target)
low = mid+1;
else // A[mid] > target
high = mid-1;
}
return -1;
}
2.给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]等于target，不存在则返回-1 。
int searchFirstPos(int A[], int n, int target)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low)>>1);
if(A[mid] < target)
low = mid+1;
else // A[mid] >= target
high = mid;
}
/*
循环过程中，当low大于0时，A[low-1]是小于target的，因为A[mid] < target时，
low=mid+1；当high小于n-1时，A[high]是大于等于target的，因为A[mid] >= target时，
high = mid；循环结束时，low 等于 high，所以，如果A[low](A[high])等于target，
那么low(high)就是target出现的最小位置，否则target在数组中不存在。
*/
if(A[low] != target)
return -1;
else
return low;
}
3.给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]等于target，不存在则返回-1
此题也就是求target在数组中最后一次出现的位置。与上一题基本一样，但是有个地方要注意，具体请参考实现代码与注释。
int searchLastPos(int A[], int n, int target)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
/*
这里中间位置的计算就不能用low+((high-low)>>1)了，因为当low+1等于high
且A[low] <= target时，会死循环；所以这里要使用low+((high-low+1)>>1)，
这样能够保证循环会正常结束。
*/
int mid = low+((high-low+1)>>1);
if(A[mid] > target)
high = mid-1;
else // A[mid] <= target
low = mid;
}
/*
循环过程中，当high小于n-1时，A[high+1]是大于target的，因为A[mid] > target时，
high=mid-1；当low大于0时，A[low]是小于等于target的，因为A[mid] <= target时，
low = mid；循环结束时，low 等于 high，所以，如果A[high](A[low])等于target，
那么high(low)就是target出现的最大位置，否则target在数组中不存在。
*/
if(A[high] != target)
return -1;
else
return high;
}
4.给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]小于target，不存在则返回-1。
int searchLastPosLessThan(int A[], int n, int target)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low+1)>>1); // 注意，不要导致死循环
if(A[mid] < target)
low = mid;
else // A[mid] >= target
high = mid-1;
}
/*
循环过程中，当low大于0时，A[low]是小于target的，因为A[mid] < target时，
low=mid；当high小于n-1时，A[high+1]是大于等于target的，因为A[mid] >= target时，
high = mid-1；循环结束时，low 等于 high，所以，如果A[low](A[high])小于target，
那么low(high)就是要找的位置，否则不存在这样的位置（A[0] >= target时）。
*/
return A[low] < target ? low : -1;
}
5.给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]大于target，不存在则返回-1。
int searchFirstPosGreaterThan(int A[], int n, int target)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low)>>1);
if(A[mid] > target)
high = mid;
else // A[mid] <= target
low = mid+1;
}
/*
循环过程中，当low大于0时，A[low-1]是小于等于target的，因为A[mid] <= target时，
low=mid+1；当high小于n-1时，A[high]是大于target的，因为A[mid] > target时，
high = mid；循环结束时，low 等于 high，所以，如果A[high](A[low])大于target，
那么high(low)就是要找的位置，否则不存在这样的位置（A[n-1] <= target时）。
*/
return A[high] > target ? high : -1;
}
有一些规律可以帮助记忆，不用临时想很多。要求最小的xx，就用
low = mid + 1; high = mid;
要是求最大的xx,就用
low = mid + 1; high = mid - 1; 而且 mid = low + ((high - low + 1) >> 1)
做几个题目拓展一下。
1.LeetCode-74 搜索二维矩阵
tips：这题其实是二分查找的一个小变形，平常的二分查找是在一维数组中进行的，而这次实在二维数组中，可以把它看成一个一维数组。
bool searchMatrix(vector<vector<int> >& matrix, int target)
{
int m = matrix.size();
if(m == 0) return false;
int n = matrix[0].size();
if(n == 0) return false;
int low = 0, high = m * n - 1;
while(low <= high)
{
int mid = low + ((high - low) >> 1);
if(matrix[mid/n][mid%n] == target)
{
return true;
}
else if(matrix[mid/n][mid%n] > target)
{
high = mid - 1;
}
else
{
low = mid + 1;
}
}
return false;
}
}
2.LeetCode-69 x的平方根
tips：这题说白了就是上面的找最大小于某个数的那种方法。从1到X挨个去尝试即可。
int mySqrt(int x) {
if (x == 0)
return 0;
int left = 1, right = x;
while (true) {
int mid = left + (right - left)/2;
if (mid > x/mid) {
right = mid ;
} else {
if (mid + 1 > x/(mid + 1))
return mid;
left = mid + 1;
}
}
}
3.LeetCode-50 Pow(n,x)
tips:这题运用了类似二分查找的方法，考察灵活运用。
double myPow(double x, int n)
{
if(n == 0) return 1; //两个边界条件0或者1的时候
if(n == 1) return x;
if(n < 0) // 如果n小于零，要特殊考虑
{
n= -n;
x = 1 / x;
}
double res = myPow(x, n/2);
if(n % 2 == 0 && !isinf(res*res))
return res*res;
else if(n % 2 == 1 && !isinf(res*res*x))
return x*res*res;
else return 0.0;
}
tips:可以转换为 找最小的大于等于target问题。
public:
int searchInsert(vector<int>& nums, int target)
{
int len = nums.size();
if(target < nums[0])
return 0;
if(target > nums[nums.size()-1])
return nums.size();
int low = 0, high = len - 1;
while(low <high)
{
int mid = low + ((high - low ) >> 1);
if(nums[mid] >= target)
high = mid;
else
low = mid + 1 ;
}
return low ;
}
5.LeetCode-33 搜索旋转排序数组
tips:见注释
int search(vector<int>& nums, int target)
{
int low = 0, high = nums.size() - 1;
//关键点在于找到最小值的坐标
//这里采用二分法进行操作，如果中间值比最后一个值还要大，说明还要右移，否则的 话左移
while(low < high)
{
int mid = (high + low) >> 1;
if(nums[mid] > nums[high])
low = mid + 1;
else
high = mid;
}
int rot = low;
low = 0; high = nums.size()-1;
while(low <= high)
{
int mid = (low+high)/2;
int realmid = (mid + rot) % nums.size();
if(nums[realmid] == target) return realmid;
if(nums[realmid] < target) low = mid + 1;
else
high = mid - 1;
}
return -1;
}
LeetCode-29 两数相乘
tips:类似二分法的尝试性算法。
int divide(int dividend, int divisor) {
if (!divisor || (dividend == INT_MIN && divisor == -1))
return INT_MAX;
int sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1;
long long dvd = labs(dividend);
long long dvs = labs(divisor);
int res = 0;
while (dvd >= dvs) {
long long temp = dvs, multiple = 1;
while (dvd >= (temp << 1)) {
temp <<= 1;
multiple <<= 1;
}
dvd -= temp;
res += multiple;
}
return sign == 1 ? res : -res;
}
114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
