STL 二分查找三兄弟（lower_bound(),upper_bound(),binary_search())

一：起因

（1）STL中关于二分查找的函数有三个：lower_bound 、upper_bound 、binary_search  —— 这三个函数都运用于有序区间（当然这也是运用二分查找的前提），下面记录一下这两个函数；

（2）ForwardIter lower_bound(ForwardIter first, ForwardIter last,const _Tp& val)算法返回一个非递减序列[first, last)中的第一个大于等于值val的位置；

（3）ForwardIter upper_bound(ForwardIter first, ForwardIter last, const _Tp& val)算法返回一个非递减序列[first, last)中的第一个大于值val的位置。

二：lower_bound和upper_bound如下图所示：

（1）lower_bound函数源代码：

//这个算法中，first是最终要返回的位置int lower_bound(int *array, int size, int key){    int first = 0, middle;    int half, len;    len = size;    while(len > 0) {        half = len >> 1;        middle = first + half;        if(array[middle] < key) {                 first = middle + 1;                      len = len-half-1;       //在右边子序列中查找        }        else            len = half;            //在左边子序列（包含middle）中查找    }    return first;}

分析：既然lower_bound()函数返回的是first的指针，那就看first指针变化的位置——first = middle + 1;的条件是 严格的小于（<），即大于等于（>=）时first的位置是不变的。或者可以这样理解，当middle指向的值 < key时，first 指向middle的下一个位置，而下一个位置可能等于或者大于key;因此 该函数是返回一个非递减序列[first, last)中的第一个大于等于值val的位置。

（2）upper_bound函数源代码：

int upper_bound(int *array, int size, int key){    int len = size-1;    int half, middle;    while(len > 0){        half = len >> 1;        middle = first + half;        if(array[middle] > key)     //中位数大于key,在包含last的左半边序列中查找。            len = half;        else{            first = middle + 1;    //中位数小于等于key,在右半边序列中查找。            len = len - half - 1;        }    }    return first;}

分析：既然upper_bound()函数返回的是first的指针，那就看first指针变化的位置——first = middle + 1;的条件是 小于等于（<=），即只有严格大于（>）时first的位置是不变的。或者可以这样理解，当middle指向的值 <= key时，first 指向middle的下一个位置，而下一个位置可能等于或者大于key,但是要是仍是等于的话，first会继续指向middle的下一位置，直到大于为止;因此 该函数是返回一个非递减序列[first, last)中的第一个大于值val的位置。

（3）binary_search函数源代码

//int BinSearch(SeqList*R，int n,KeyType K)int bin_search(int arr[],const int &n,const int &k){//在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回-1    int low=0,high=n-1,mid;//置当前查找区间上、下界的初值    while(low<=high)    {        mid=low+((high-low)/2);        //使用(low+high)/2会有整数溢出的问题        //（问题会出现在当low+high的结果大于表达式结果类型所能表示的最大值时，        //这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)不存在这个问题        if(arr[mid] == k)            return mid;//查找成功返回        if(arr[mid] > k)            high=mid-1;//继续在R[low..mid-1]中查找        else            low=mid+1;//继续在R[mid+1..high]中查找    }    if(low>high)        return low;//当low>high时表示所查找区间内没有结果，查找失败}int bin_search2(int arr[],const int &n,const int &k){if(arr && n>0)// 对数组和数组长度进行了判断，非常好的改进，上面也应该由此个改进的{int low,mid,high;float rate;low = 0;high = n-1;while(low<=high){rate = (k-arr[low])*1.0/(arr[high]-arr[low]);if(rate>1 || rate <0)// 对应数组的边界，不在数组中return -1;mid = low+(high-low)*rate;if(arr[mid] == k)return mid;else if(arr[mid] > k)high = mid - 1;elselow = mid + 1;}return -1;// 查找失败}return -1;}

分析：既然binary_search()函数返回的是middle 或 未找到时的指针，那就看middle指针变化的位置——mid = low + (high - low)/2;的条件是最外层while的条件（没有条件限制）第一次相等时就返回middle或者查找失败;因此 该函数是返回一个非递减序列[first, last)中的第一次找到的等于值val的位置，有可能是第一个中间的最后一个（如有序序列 ……3 3 3 ……）。

三：比较说明

（1）分析：既然lower_bound()函数返回的是first的指针，那就看first指针变化的位置——first = middle + 1;的条件是 严格的小于（<），即大于等于（>=）时first的位置是不变的。或者可以这样理解，当middle指向的值 < key时，first 指向middle的下一个位置，而下一个位置可能等于或者大于key;因此 该函数是返回一个非递减序列[first, last)中的第一个大于等于值val的位置。

（2）分析：既然upper_bound()函数返回的是first的指针，那就看first指针变化的位置——first = middle + 1;的条件是 小于等于（<=），即只有严格大于（>）时first的位置是不变的。或者可以这样理解，当middle指向的值 <= key时，first 指向middle的下一个位置，而下一个位置可能等于或者大于key,但是要是仍是等于的话，first会继续指向middle的下一位置，直到大于为止;因此 该函数是返回一个非递减序列[first, last)中的第一个大于值val的位置。

（3）分析：既然binary_search()函数返回的是middle 或 未找到时的指针，那就看middle指针变化的位置——mid = low + (high - low)/2;的条件是最外层while的条件（没有条件限制）第一次相等时就返回middle，或者查找失败;因此 该函数是返回一个非递减序列[first, last)中的第一次找到的等于值val的位置，有可能是第一个中间的最后一个（如有序序列 ……3 3 3 ……）。

（4）更正说明（优化说明）形式统一，格式统一，这样比较好的，就是不要太脱离你比较熟悉的binary_search()函数的形式，或者核心思想

#include <iostream>using namespace std;//这个算法中，first是最终要返回的位置int lower_bound(int *array, int size, int key){    int first = 0, middle;    int half, len;    len = size;    while(len > 0) {        half = len >> 1;        middle = first + half;        if(array[middle] < key) {            first = middle + 1;            len = len-half-1;       //在右边子序列中查找        }        else            len = half;            //在左边子序列（包含middle）中查找    }    return first;}int upper_bound(int *array, int size, int key){    int first = 0;    int len = size-1;    int half, middle;    while(len > 0){        half = len >> 1;        middle = first + half;        if(array[middle] > key)     //中位数大于key,在包含last的左半边序列中查找。            len = half;        else{            first = middle + 1;    //中位数小于等于key,在右半边序列中查找。            len = len - half - 1;        }    }    return first;}int lower(int *,int,int);int upper(int*,int,int);int main(){    int key;    cout << "Hello world!" << endl;    int arr[] = {1,2,2,3,4,4,4,4,5,6,7,9,9,10};    while(cin >> key)    {        cout << "1ziji: " << lower(arr,sizeof(arr)/sizeof(arr[0]),key) << endl;        cout << "2: " << lower_bound(arr,sizeof(arr)/sizeof(arr[0]),key) << endl;        cout << "3: " << upper_bound(arr,sizeof(arr)/sizeof(arr[0]),key) << endl;        cout << "4ziji: " << upper_bound(arr,sizeof(arr)/sizeof(arr[0]),key) << endl;    }    return 0;}int lower(int arr[],int size,int key){    if(arr && size > 0)    {        int l = 0;        int r = size -1;        int mid;        while(l < r)        {            mid = l + (r-l)/2;            if(*(arr+mid)>=key)                r = mid;            else                l = mid + 1;        }        return l;    }    return -1;}int upper(int*arr,int size,int key){   if(arr && size > 0)    {        int l = 0;        int r = size -1;        int mid;        while(l < r)        {            mid = l + (r-l)/2;            if(arr[mid]>key)                r = mid;            else                l = mid+1;        }        return l;    }    return -1;}

（5）运行结果（当时没有upper()函数的）

加上upper（）函数之后的效果如下：