其實這兩個函式只能用於 “升序” 序列。

#include<bits/stdc++.h>
using namespace std;
int main() {
  int a[] = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4};
 
  cout << (lower_bound(a, a + 12, 4) - a) << endl; //輸出 9
  cout << (upper_bound(a, a + 12, 4) - a) << endl; //輸出 12
  cout << (lower_bound(a, a + 12, 1) - a) << endl; //輸出 0
  cout << (upper_bound(a, a + 12, 1) - a) << endl; //輸出 3
  cout << (lower_bound(a, a + 12, 3) - a) << endl; //輸出 6
  cout << (upper_bound(a, a + 12, 3) - a) << endl; //輸出 9
  cout << (lower_bound(a, a + 12, 5) - a) << endl; //輸出 12
  cout << (upper_bound(a, a + 12, 5) - a) << endl; //輸出 12
  cout << (lower_bound(a, a + 12, 0) - a) << endl; //輸出 0
  cout << (upper_bound(a, a + 12, 0) - a) << endl; //輸出 0
 
  return 0;
}
 

那麼如果是降序序列呢？如果是降序序列，這個函式仍然以為你這個序列是升序的，

我們以{4,4,4,3,3,3,2,2,2,1,1,1}作為例子，試驗一下。

#include<bits/stdc++.h>
using namespace std;
int main() {
  int a[] = {4, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1};
 
  cout << (lower_bound(a, a + 12, 4) - a) << endl; // 輸出 12
  cout << (upper_bound(a, a + 12, 4) - a) << endl; // 輸出 12
  cout << (lower_bound(a, a + 12, 1) - a) << endl; // 輸出 0
  cout << (upper_bound(a, a + 12, 1) - a) << endl; // 輸出 0
  cout << (lower_bound(a, a + 12, 3) - a) << endl; // 輸出 12
  cout << (upper_bound(a, a + 12, 3) - a) << endl; // 輸出 12
  
  return 0;
}
 

以這句為例 lower_bound(a, a + 12, 4) ，因為是二分查詢，第一步從中間開始，取中間值 a[(0+12)/2] = a[6] = 2 ，比 4 小，但是他想要找到第一個大於等於 4 的，所以繼續向更大的值靠近，向哪邊靠近呢，右邊，因為他以為你這是升序的，所以取右半部分中間值 a[(7+12)/2] = a[9] = 1，比 4 小，所以繼續向更大的值靠近，取右半部分中間值 a[(10+12)/2] = a[11] = 1，比 4 小，所以繼續向更大的值靠近，取右半部分中間值 a[(12+12)/2] = a[12]，到這不用取了，到頭了，該返回了，所以最終返回了尾迭代器。
 

簡單來講就是： 
 lower_bound(ForwardIter first, ForwardIter last,const _Tp& val)演算法返回一個非遞減序列[first, last)中的第一個大於等於值val的位置。

upper_bound(ForwardIter first, ForwardIter last, const _Tp& val)演算法返回一個非遞減序列[first, last)中第一個大於val的位置。
 

 首先是我修改資料結構課本上的二分查詢實現的lower_bound演算法：

int my_lower_bound(int *array, int size, int key)
{
    int first = 0, last = size-1;
    int middle, pos=0;       //需要用pos記錄第一個大於等於key的元素位置

    while(first < last)
    {
        middle = (first+last)/2;
        if(array[middle] < key){      //若中位數的值小於key的值，我們要在右邊子序列中查詢，這時候pos可能是右邊子序列的第一個
            first = middle + 1;
            pos = first;
        }
        else{
            last = middle;           //若中位數的值大於等於key，我們要在左邊子序列查詢，但有可能middle處就是最終位置，所以我們不移動last,
            pos = last;              //而是讓first不斷逼近last。
        }
    }
    return pos;
}

STL中原始碼：

//這個演算法中，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;
}

upper_bound返回的是最後一個大於等於val的位置，也是有一個新元素val進來時的插入位置。

我依然將二分查詢略做修改：

int my_upper_bound(int *array, int size, int key)
{
    int first = 0, last = size-1;
    int middle, pos = 0;

    while(first < last)
    {
        middle = (first+last)/2;
        if(array[middle] > key){     //當中位數大於key時，last不動，讓first不斷逼近last
            last = middle;
            pos = last;
        }
        else{
            first = middle + 1;     //當中位數小於等於key時，將first遞增，並記錄新的位置
            pos = first;
        }
    }
    return pos;
}

STL中的upper_bound實現：

int upper_bound(int *array, int size, int key)
{
    int first = 0, 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;
}