二分搜索总结

编程之美上有节说各种二分的查找，于是便写了下，并给出了一些测试代码

1）二分查找元素key的下标，如无 return -1

2）二分查找返回key(可能有重复)第一次出现的下标，如无return -1

3）二分查找返回key(可能有重复)最后一次出现的下标，如无return -1

4）二分查找返回刚好小于key的元素下标，如无return -1

5）二分查找返回刚好大于key的元素下标，如无return -1

写中间有一些需要注意的地方，都在代码中写了，关键还是要处理好边界问题，下面是代码

#include <cstdio>
#include <cmath>
#include <cstdlib>
// 1.二分查找元素key的下标，如无 return -1
int binarySearch( int *arr, int fisrt, int last, int key )
{
// err check
// if ( arr == NULL || fisrt > last )
// return -1;
// 注意查找的范围
// 左闭右开、左闭右闭
int low = fisrt;
int upper = last;
while ( low <= upper )
{
int m = low + (( upper - low ) >> 1);
if ( arr[m] == key )
return m;
else if ( arr[m] < key )
low = m + 1; // 此处因为搜索区间所以是 m+1
else
upper = m - 1; // 此处因为搜索区间所以是 m-1
}
return -1;
}
// 2）二分查找返回key(可能有重复)第一次出现的下标，如无return -1
int getFirstIndexOfKey( int *arr, int fisrt, int last, int key )
{
// err check
// if ( arr == NULL || fisrt > last )
// return -1;
int low = fisrt;
int upper = last;
while ( low <= upper )
{
int m = low + (( upper - low ) >> 1);
// 此处的关键是怎么处理 arr[m] == key
// 举个例子：1 1 2 2 3
// 下标：0 1 2 3 4
// m = ( 0 + 4) / 2 = 2;
// 此时 arr[2] == 2，那么此时应该明确前面是否有2了，
// 接着 求 [0,1] 中是否有2了，假如没有了，那结束的时候，low == upper + 1，此时查看low处是否是2，是则返回
if ( key <= arr[m] )
upper = m - 1; // 当arr[m] == key 时，则 位置m 可能是第一次出现的下标
else
low = m + 1;
}

if ( low <= last && arr[low] == key )
return low;
else
return -1;
}
//3）二分查找返回key(可能有重复)最后一次出现的下标，如无return -1
// 关键是处理arr[m] == key时怎么办，此时应该是找 [m+1,upper]里面是否有key了
// 当没有时候时候，此时结束条件是upper=m，故此时判断是否arr[upper] == key
int getLastIndexOfKey( int *arr, int fisrt, int last, int key )
{
int low = fisrt;
int upper = last;
while ( low <= upper )
{
int m = low + (( upper - low ) >> 1);
if ( key >= arr[m] )
low = m + 1;
else
upper = m - 1;
}
if ( upper >= fisrt && arr[upper] == key )
return upper;
else
return -1;
}

//4）二分查找返回刚好小于key的元素下标，如无return -1
// 分几种情况考虑
// 1.假设[low,upper]中有数等于key,即arr[m] == key
// 则此时应该找 [low,m-1]，并假设此时是最后一个 arr[m] == key，则此时[low,m-1] < key,结束条件是low==m,返回upper即可
// 2.假设[low,upper]没有key即，arr[low]<key<arr[uperr],则必然缩小到最后有 low + 1 = upper,此时结束时返回upper
// 3.特殊情况考虑：key < [low,upper] , 则结束时 upper < low，返回-1
// [4.low,upper] < key， 则结束时，low >upper,返回upper
int binarySearchJustSmaller( int *arr, int fisrt, int last, int key )
{
int low = fisrt;
int upper = last;
while( low <= upper )
{
int m = low + (( upper - low ) >> 1);
if ( key <= arr[m] )
upper = m - 1;
else
low = m + 1;
}
if ( upper >= fisrt || arr[upper] < key )
return upper;
else
return -1;
}
// 5）二分查找返回刚好大于key的元素下标，如无return -1
// 分几种情况
// 1.假设[low,upper]中有数等于key,即arr[m] == key，则查找[m+1,upper]，返回low即可
// 2.假设[low,upper]没有key即，arr[low]<key<arr[uperr],则必然缩小到最后有 low + 1 = upper,此时结束时返回low
// 3.特殊情况考虑：key < [low,upper] , 则结束时 upper < low，返回low
// [4.low,upper] < key， 则结束时，low >upper,返回-1
int binarySearchJusBigger( int *arr, int fisrt, int last, int key )
{
int low = fisrt;
int upper = last;
while( low <= upper )
{
int m = low + (( upper - low ) >> 1);
if ( arr[m] <= key )
low = m + 1;
else
upper = m - 1;
}
if ( low <= last || arr[low] > key )
return low;
else
return -1;
}

#define GetSize(arr) ( sizeof arr / sizeof arr[0])

void Test( char *name, int *arr, int size, int key, int *index )
{
if ( name != NULL )
printf("===============%s begin===================\n",name);

if ( binarySearch(arr,0,size-1,key) == index[0] )
printf("binarySearch passed.\n");
else
printf(" binarySearch failed.\n");

if ( getFirstIndexOfKey(arr,0,size-1,key) == index[1] )
printf("getFirstIndexOfKey passed.\n");
else
printf(" getFirstIndexOfKey failed.\n");

if ( getLastIndexOfKey(arr,0,size-1,key) == index[2] )
printf("getLastIndexOfKey passed.\n");
else
printf(" getLastIndexOfKey failed.\n");

if ( binarySearchJustSmaller(arr,0,size-1,key) == index[3] )
printf("binarySearchJustSmaller passed.\n");
else
printf(" binarySearchJustSmaller failed.\n");

if ( binarySearchJusBigger(arr,0,size-1,key) == index[4] )
printf("binarySearchJusBigger passed.\n");
else
printf(" binarySearchJusBigger failed.\n");

if ( name != NULL )
printf("===============%s end=================\n",name);
}
// 常规测试
void Test1()
{
int arr[] = {1,2,3,4,5};
int size = GetSize(arr);
int index[] = {0,0,0,-1,1};
Test("test1",arr,size,1,index);
}

void Test2()
{
int arr[] = {1,2,3,4,5};
int size = GetSize(arr);
int index[] = {1,1,1,0,2};
Test("test2",arr,size,2,index);
}

void Test3()
{
int arr[] = {1,2,3,4,5};
int size = GetSize(arr);
int index[] = {4,4,4,3,-1};
Test("test3",arr,size,5,index);
}
// 全都一样时
void Test4()
{
int arr[] = {1,1,1,1,1};
int size = GetSize(arr);
int index[] = {2,0,4,-1,-1};
Test("test4",arr,size,1,index);
}
// 都大
void Test5()
{
int arr[] = {1,2,3,4,5};
int size = GetSize(arr);
int index[] = {-1,-1,-1,-1,0};
Test("test5",arr,size,0,index);
}
// 都小
void Test6()
{
int arr[] = {1,2,3,4,5};
int size = GetSize(arr);
int index[] = {-1,-1,-1,4,-1};
Test("test6",arr,size,6,index);
}

void Test7()
{
int arr[] = {1,2,4,5,6};
int size = GetSize(arr);
int index[] = {-1,-1,-1,1,2};
Test("test7",arr,size,3,index);
}
int main()
{
Test1();
Test2();
Test3();
Test4();
Test5();
Test6();
Test7();

return 0;
}