二分查找是在技术面试中经常出现的题目，首先这种题目考察思路，另外因为代码一般很短----不会超过50行。所以很适合做技术笔试，或者面试之类的题目出现。
之前做过一些题目，很多是BS算法的变种，我这里给出几个例子，算是做一个总结吧。
1. 传统的Binary Search
1.1. 最普通的BS算法就是给定一个排好序的数组，然后查找一个数是否在数组内，如果在给出下标，如果不在则返回-1.
template<typename T>
int binarySearch(const T vData[], int nSize, const T &query)
{
int l, u, m;
l = 0;
u = nSize - 1;
while(l <= u)//算法需要注意的是 选择的 l 和u， 如果u 选择的是size的话，这个条件会不一样
{
m = (l + u)/2;
if(vData[m] == query) //找到返回
{
return m;
}
else if(vData[m] > query) //当前元素大于要找的元素
{
u = m - 1;
}
else
{
l = m + 1;
}
}
return -1;
}
1. 2 比普通的BS算法稍微复杂一点的应该是在字典中查找一个指定的字符串了。
对于输入的所有单词，我们可以使用排序算法使得所有单词按照字典序排列，然后用BS算法找到给定的元素的下标。
代码如下：
#define MAXCHARLEN 50
int binarySearch(const char directionary[][MAXCHARLEN], int nSize, const char* pQuery)
{
int l, u;
l = 0;
u = nSize - 1;
int m;
int cmpResult;
while(l <= u)
{
m = (l + u)/2;
cmpResult = strcmp(directionary[m], pQuery);//先保存结果，以免被计算好几次
if(cmpResult == 0)
{
return m;
}
else if(cmpResult == 1)
{
u = m - 1;
}
else
{
l = m + 1;
}
}
return -1;
}
2. 含有空的Bianry Search
这个问题的一种描述形式可能如下：
在给定的字符串序列中（按照字典序排列好的）， 存在一些空串，请你找出给定字符串的位置，不在里面返回 -1.
例如 char directionary[] = {"", "a", "ab", "", "", "", "bb", "cc", "zz", "" ""} 中需找 "ab";
这里需要添加一些处理，在找到binary search的中心点以后，如果是空，我们要移动当前的m
#include<stdio.h>
#include <string.h>
#include<memory.h>
#define MAXCHARLEN 50
int binarySearch(const char directionary[][MAXCHARLEN], int nSize, const char* pQuery)
{
int l, u;
l = 0;
u = nSize - 1;
int m;
int cmpResult;
while(l <= u)
{
m = (l + u)/2;
while(m > l && directionary[m][0] == '\0') //这个位置稍微不小心就留下bug了，或许我这里依然有bug存在。
{
m--;
}
cmpResult = strcmp(directionary[m], pQuery);
if(cmpResult == 0)
{
return m;
}
else if(cmpResult == 1)
{
u = m - 1;
}
else
{
l = m + 1;
}
}
return -1;
}
int main()//test cases.
{
const char directionary[][MAXCHARLEN] =
{
"", "aa", "", "bb", "", "cc", "dd", "e", "", "", "ff"
};
const char query[][MAXCHARLEN] =
{
"aa", "bb", "cc", "dd", "kk", "e"
};
for( int i = 0; i < 6; i++)
{
printf("%d ", binarySearch(directionary, 11, query[i]));
}
return 0;
}
3. Rotated Sorted Array
这种问题有一个描述是说，已知我们有一个数组，它是在一个排序数组的基础上，用rotate的方式生成出来的。
例如： 3 4 5 1 2 就是一个符合上面说法的数组。
现在有如下两个任务：
3.1 查找到某个元素（Search for a specific element).
此类问题的分析的时候，一个核心的思路应该是说，无论数组[l, u]被分开后，[l, m-1], [m+1, u]其中一定至少有一个是已经排好序的了，并且这个排序的区间内的所有元素，和另一个区间 是不会相互覆盖的。
例如 3 4 5 1 2, 如果分成 3 4, 5 1 2, 不会有交叠的情况，就是说 各自依然满足原始 ratated sorted array的定义。
所以可以用binary search 的方法来做搜索。
不过这些代码特别容易写出bug，虽然看起来很简单。
#include<stdio.h>
#include <string.h>
#include<memory.h>
bool InRange(int l, int u, int query)
{
return query >= l && query <= u;
}
int binarySearch(int rotatedArray[], int nSize, int query)
{
int lower, upper;
lower = 0, upper = nSize - 1;
int m;
while(lower <= upper)
{
m = (lower + upper)/2;
if(rotatedArray[m] == query)
{
return m;
}
if(rotatedArray[m] >= rotatedArray[lower]) //如果第一个区间是排序区间
{
if(InRange(rotatedArray[lower], rotatedArray[m], query))//如果当前搜索在排序区间内
{
upper = m - 1;
}
else//检索元素不在排序区间内
{
lower = m + 1;
}
}
else//另一半是排序区间
{
if(InRange(rotatedArray[m], rotatedArray[upper], query))//在排序区间内
{
lower = m + 1;
}
else//不在排序区间内
{
upper = m - 1;
}
}
}
return -1;
}
int main()
{
int a[] = {3, 5, 7, 9, 0, 2};
for(int i = 0; i < 10; i++)
{
printf("i: %d is at %d\n",i, binarySearch(a, 6, i));
}
return 0;
}
3.2 找到最小元素（Search for the minumum or maximum ）
如果我们查找的区间中 a[lower] < a[upper] 那么我们可以断定，我们当前搜索的区间是完全排序的，没有rotated，可以直接返回 a[lower].
如果 lower == upper 我们只有一个元素， 也可以直接返回 a[lower];
在其他情况，我们可以可以用binary search的思想。
如果 a[m] >= a[lower]， 说明从a[lower] -> a[m]是排序好的，a[lower] < a[upper]的条件又不满足，所以搜索区间一定再另一侧。
否则搜索区间在 a[m], a[lower].
int findMin(int a[], int lower, int upper)
{
if(a[lower] <= a[upper]) //包括2个case， 1：搜索到最小区间 2: 全区间已经是排序区间，则直接返回最小那个数
{
return lower;
}
int m = (lower + upper)/2;
if(a[m] >= a[lower] )//如果 lower ... m 是排序区间，并且整个大的区间不是排序区间，那么下一步搜索转到 m + 1, upper.
{ //等于号为了防止 例如输入是 6 1这样的情况，在这个情况下 m == lower
return findMin(a, m+1, upper);
}
else
{
return findMin(a, lower, m); //否则搜索当前区间
}
}
int main() // generate test case
{
int a[10];
for( int i = 0; i < 6; i++)
{
for( int j = 0; j < 6; j++)
{
a[ (i + j)%6] = j;
}
for( int j = 0; j < 6; j++)
{
printf("%d ", a[j]);
}
printf("\nMin at %d\n", findMin(a, 0, 5));
}
return 0;
}
4. 统计出现的次数
这个题目的描述可以是这样：
在一个排序好的数组中，有一些元素是重复的。 我们写一个函数，对给定的数，我们返回这个数出现的次数。
例如输入数据 1 2 2 3 3 3 5 5，如果输入2， 返回2，因为2在数组中出现2次。
这个问题可以引入两个子问题，寻找到 Query（Q）第一次出现的位置，和Q最后一次出现的位置。
我们可以称之为 lower_bound, 和 upper_bound
int findLowerBound(int a[], int nSize, int query)
{
int lower, upper;
int m;
lower = 0, upper = nSize - 1;
while(lower <= upper)
{
m = (lower + upper)>>1;
if(a[m] == query)
{
while(a[--m] == query);
return m+1;
}
else if(a[m] > query)
{
upper = m - 1;
}
else
{
lower = m + 1;
}
}
return -1;
}
int findUpperBound(int a[], int nSize, int query)
{
int lower, upper, m;
lower = 0, upper = nSize - 1;
while(lower <= upper)
{
m = (lower + upper) >> 1;
if(a[m] == query)
{
while(a[++m] == query);
return m-1;
}
else if(a[m] > query)
{
upper = m - 1;
}
else
{
lower = m + 1;
}
}
return -1;
}
int main() //generate test case
{
int a[] = {1, 2, 2, 3, 3, 3, 5, 5, 5}; //size is 9
int l, u;
//int *p = lower_bound(a, a + 9, 0);
for( int i = 0; i < 7; i++)
{
l = findLowerBound(a, 9, i);
u = findUpperBound(a, 9, i);
if( l != -1)
{
printf("l:%d u:%d (u-l):%d\n", l, u, u - l + 1);
}
else
{
printf("Can't find\n");
}
}
return 0;
}补充：（感谢NickMouse)
不过这个算法在极端的情况下,复杂度会降低到 O(n), 给出一些改进的代码
by NickMouse:
#include <stdio.h>
int bsearch_lowerbound(int a[],int n,int x)
{
int l=0,r=n-1;
while(l+1<r){
int m=(l+r)/2;
if(a[m]>=x)
r=m;
else
l=m+1;
}
if(a[l]==x)
return l;
else if(a[r]==x)
return r;
else
return -1;
}
int bsearch_upperbound(int a[],int n,int x)
{
int l=0,r=n-1;
while(l+1<r){
int m=(l+r)/2;
if(a[m]<=x)
l=m;
else
r=m-1;
}
if(a[r]==x)
return r;
else if(a[l]==x)
return l;
else
return -1;
}
int main()
{
int a[] = {1,1, 2, 3, 3,3, 5};
for(int i = 0; i < 6; i++)
{
printf("%d\n", bsearch_lowerbound(a, 7, i));
}
return 0;
}
5. 需找第一个大于（或小于） 指定数的数
说起来有点不好懂，给个例子。
例如升序数组 1 4 5 8, 如果输入的是 7, 我们应该返回8， 因为8 是第一个大于输入：7的数。
其实这个算法有一个很重要的作用是在O(Nlog(N))的最长递增子序列里面，每次扫描到一个数，我们要知道这个数，可以作为长度是几的递增子序列的最后元素。
//1 4 5 8 ---> 7
int FindFirstLarger(int a[], int nSize, int query)
{
int lower = 0;
int upper = nSize - 1;
int m ;
while(lower <= upper)
{
m = (lower + upper) / 2;
if(a[m] < query)
{
lower = m + 1;
}
else
{
upper = m - 1;
}
}
return lower;
}
int main()
{
int a[] = {1, 4, 5, 8}; //size is 9
for(int i = 0; i < 10; i++)
{
printf("i: %d at: %d\n", i, FindFirstLarger(a, 4, i));
}
return 0;
}6. 在 行列 排序的矩阵中里面需找某个元素
例如如下输入：
1 5 7 10
2 6 8 15
4 9 11 16
12 13 19 21
输入满足按行来看，是递增排序，按列也是递增排序。现在要找到某个元素，如果存在，则输出 -1
因为按行和按列是排好序的，所以对于任意一个元素来说，它的左边所有元素比它，它下面的元素比它大，利用这个性质，我们可以设计出一个 二分查找。这个查找从 第0行的最后一个元素开始。按照比较结果，决定向下，还是向左覆盖整个区间。
代码如下：
bool SearchInRowColSortedMatrix(const int data[], int nRow, int nCol, int query, int &tRow, int &tCol)
{
int iRow, iCol;
iRow = 0;
iCol = nCol - 1;
int t;
while(iRow < nRow && iCol >= 0)
{
t = data[iRow * nCol + iCol];//get the current data.
if( t == query) //find it
{
tRow = iRow;
tCol = iCol;
return true;
}
else if( t < query) // eleminate the rest of the elements in the current row, who are less than t.
{
iRow++;
}
else //eleminate all the rest elements in current col, who are greater than t.
{
iCol--;
}
}
return false;
}写在最后：
上面的代码可能有一些地方有bug， 虽然我做了一些测试，包括穷举所有内部元素的 正测试，还有不在查找数组中的反测试。 这些代码确实很容易出bug，对于一些大公司如MS等比较看重代码，要求bug-free的公司可能经常作为考题，来考察现场编程能力。 不过自己依然很水，还需要努力，努力写出bug-free的code
扫一扫
255
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
