二分查找的一些细节,考虑重复元素的前提下,拒绝死循环和未找到

基础版

注意点都通过注释标出
缺陷: 查找的key 有重复元素会返回重复元素中的任意一个

#include<stdio.h>
int BinarySearch_1(int *a,int length, int key)
{
    if( a == NULL || length <= 0  )
    {
        return -1;
    }
    int lo = 0;
    int hi = length - 1;
    int mid = lo + (hi - lo ) / 2;
    // 1 2  找2  
    //    while(lo < hi) 找不到 2  
    while( lo <= hi )
    {
        if( a[mid] < key )
        {
        //  1 2 找 2   lo不 + 1 死循环
            lo = mid + 1;
        }
       else if( a[mid] > key )
        {
            hi = mid - 1;
        }
        else if( a[mid] == key )
        {
            return mid;
        }
    }
    return -1;
}

返回第一次出现下标的位置

int BinarySearch_2(int *a,int length, int key)
{
    if( a == NULL || length <= 0 )
        return -1;
    int lo = 0;
    int hi = length - 1;
    int mid  = lo +  ( hi - lo  ) / 2;
    // 因为是 lo < hi 的形式结束循环 所以存找不到的可能,
    // 必须在循环体外部检测是否等于key
    while( lo < hi )
    {
        if( a[mid] >= key )
        {
            hi = mid;
        }
        else if( a[mid] < key )
        {
            lo = mid + 1;
        }
        mid = lo + ( hi - lo ) / 2;
    }
    //结束循环后
    //  lo = hi   查看是否等于key
    return a[lo] == key? lo: -1;
}

返回最后一个出现的下标

int BinarySearch_3(int *a,int length,int key)
{
    if( a == NULL || length <= 0 )
        return -1;
    int lo = 0;
    int hi = length - 1;
    int mid  = lo +  ( hi - lo  ) / 2;
    // 3 3找第二个3
    while( lo < hi - 1 )
    {
        if( a[mid] <= key )
        {
            lo = mid;
        }
        else if(a[mid] > key)
        {
            hi = mid - 1;
        }
        mid = lo + ( hi - lo ) / 2;
    }
    //结束循环后先判断 hi  因为要返回最后一个出现的
    return a[hi] == key? hi : a[lo] ==key? lo : -1;
}

总结

返回第一次出现和最后一次出现的差别

将第一次出现的方法 称作 frist,最后一次出现称作 last
/*
* 判断第一次出现和最后一次出现 区别
* first 运用了 除法总是向左(下)取整的特点 所以 hi 总是能通过mid 的除法向左和lo汇合
* 例如 1 1 中找 1
* mid 总是指向第一个 1
* 但 last 就不能用此方法, 还是因为因为除法总是向左边取整的
* 3 3
* lo 指向 第一个3 hi 指向第二个 3
*当 mid <= key
* lo = mid
* mid 总是在lo这一边, 此时 lo < hi 永远成立,会造成死循环
* 所以遇到这种情况就应该结束循环,将条件改为 lo < hi - 1
* 由于标准中 在lo == hi 循环体内还要判断一次
* frist的解法 也在循环外面 lo == hi时判断了一次
* 所以在向右边找最大的时候
* 应该先判断 hi 然后 判断lo
* 3 3 找 3 的情况 lo 指向第一个3 hi 指向最后一个3
* 此时应该返回 hi 而不是lo
*
*
* 3 4 4 5 key = 3
* 结束循环时 (while lo < hi - 1)
* hi = 4 lo = 3
*通过判断 应该返回 lo
*/