提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

1.二分查找算法

二分查找算法是一个ln(n)复杂度的算法，在查找中具有较高的效率
输入：一组数据array，需要查找的数key
输出：key在array中的位置

方法：递归和非递归的二分查找
代码如下（示例）：

#include <iostream>
using namespace std;
#define N 10

//非递归查找  
int BinarySearch(int *array, int aSize, int key){
    int l = 0;
    int r = aSize;
    int mid =0;
    while(l<=r){
        mid = (l+r)/2;
        //mid = l+(r-l)/2;
        if(key==array[mid])
            return mid;
        else if(key<array[mid]){
            r = mid-1;
            continue;
        }
        else{
            l = mid+1;
            continue;
        }
    }
    return -1;
}
//递归  
int BinarySearchRecursive(int *array, int low,
                          int high, int key) {
    if(low>high)
        return -1;
    int mid = (low + high) / 2;
    //int mid = low + (right-low)/2
    if (key==array[mid])
        return mid;
    else if (key<array[mid])
        return BinarySearchRecursive(array, low, mid-1, key);
    else
        return BinarySearchRecursive(array, mid+1, high, key);
}

int main() {
    int arrays[N] = {0, 1, 2, 35, 40, 41, 60, 70, 80, 99};
    // int arrays[N];
    // for(int i=0;i<N;i++)
    //     cin>>arrays[i];
    // for(int i=0;i<N;i++)
    //     cout<<arrays[i]<<" ";
    // cout<<endl;
    int key = 0;
    cout<<"需要查找的数字"<<endl;
    cin>>key;
    cout<<"递归查找: "<<key<<"是第< "
    <<BinarySearchRecursive(arrays, 0, N-1, key)<<" >个"<<endl;
    cout<<"非递归查找: "<<key<<"是第< "
    <<BinarySearch(arrays, N, key)<<" >个"<<endl;
    return 0;
}

细节

细节１：终止条件"while(l<=r)“和"if(low>high)”?

二分查找意在缩小搜索空间，搜索空间内的数都有可能是结果，比如在[1]内搜索1，l=0，r=0，显然是开始搜索的条件不是结束搜索的条件，当最后l=1，r=0时，搜索空间为空，则搜索结束。

细节２：为什么 left = mid + 1，right = mid - 1？

有的代码是 right = mid 或者 left = mid。搜索空间内的数都有可能是结果，而mid是在搜索空间之外的。本代码直接修改成这样，会导致[2,3]搜索2.5会出现死循环。

技巧１：计算 mid 时需要防止溢出，代码中 left + (right - left) / 2 就和 (left + right) / 2 的结果相同，但是有效防止了 left 和 right 太大直接相加导致溢出。

2.寻找左侧边界的二分搜索

#include <iostream>
using namespace std;
#define N 10
//寻找左侧边界的二分搜索
int left_bound(int* nums, int len, int target) {
    int l=0,r=len-1;
    int mid =0;
    while (l<=r)
    {
        mid = l+(r-l)/2;
        if(target == nums[mid])
            r = mid-1;//搜索左侧还有没有target
        else if(target < nums[mid])
            r = mid-1;
        else if(target > nums[mid])
            l=mid+1;
    }
    if((l!=len)&&(nums[l]==target))//注意l=len时的数组越界
        return l;
    return -1;
}
//寻找右侧边界的二分搜索
int right_bound(int* nums, int len, int target) {
    int l=0,r=len-1;
    int mid =0;
    while (l<=r)
    {
        mid = l+(r-l)/2;
        if(target == nums[mid])
            l = mid+1;//搜索右侧还有没有target
        else if(target < nums[mid])
            r = mid-1;
        else if(target > nums[mid])
            l=mid+1;
    }
    if((r!=-1)&&(nums[r]==target))//注意l=-1时的数组越界
        return r;
    return -1;
}

int main() {
    int arrays[N] = {1,2,3,3,3,4,4,7,8,8};
    int key = 0;
    cout<<"需要查找的数字"<<endl;
    cin>>key;
    cout << right_bound(arrays,10,key) << endl;
    return 0;
}

只要稍改 nums[mid] == target 条件处的代码和返回的逻辑即可