二分查找笔记（内附代码）

有序数组的元素不是随机分布的，而是按照大小的相对位次排列，我们默认从小到大排列。而查找函数，我们希望可以返回不大于某一值的最右边的位置，以便于配合插入函数，使插入新的元素后，仍保持有序数组。

最直接的二分查找

 int bin_search(int A[], int value, int low, int high) 
{
    while (low < high)
    {
        int mid = (low + high) >> 1;
        if (A[mid] > value)
            high = mid;
        else if (A[mid] < value)
            low = mid + 1;
        else return mid;
    }
    return -1;
}

通过分析该算法的时间复杂度，我们发现，如果要查找较小的数，需要1次比较，若查找较大的数，则需要2次查找，由于这种不平衡，我们考虑，将分割的点向后移，使前部分元素数量大于后部分，那么问题来了

分界点设置在哪里较为合适呢？

我们考虑黄金分割点，也就是用斐波那契数列分割，因此我们可以用以下代码实现：

int get_fib(int n)
{
    int before = 0;
    int last = 1;
    if (n == 1)
        return 0;
    while (1)
    {
        last = before + last;
        before = last - before;
        if ((before < n) && (n <= last))
            return before;
    }
}
int fib_search(int A[], int value, int low, int high)
{
    while (low < high)
    {
        int pre = get_fib(high - low);
        int mid = low + pre;
        if (A[mid] > value)
            high = mid;
        else if (A[mid] < value)
            low = mid + 1;
        else return mid;
    }
    return -1;
}

通过分析可知，对于一个7个数的数组，平均的查找次数为4，已经达到了改种方法的极限，因此我们尝试换种思路，将左右两部分的比较次数都设定为1次，因此，有了以下思路：

int bin_searchB(int A[], int value, int low, int high)
{
    while (low < high-1)
    {
        int mid = (low + high) >> 1;
        if (A[mid] > value)
            high = mid;
        else 
            low = mid;
    }
    if(A[low]==value)
        return low;
    else return -1;
}

但是，该算法还是存在一定的缺陷，它无法满足我们最初的要求，即当有重复元素或者没有要查找的元素时，返回值并非不大于该元素最右边的位置。因此，我们又做了如下改进：

int bin_searchC(int A[], int value, int low, int high)
{
    while (low < high )
    {
        int mid = (low + high) >> 1;
        if (A[mid] > value)
            high = mid;
        else
            low = mid + 1;
    }
    return --low;
}

除此之外，还有差值查找，顺序查找等方法，差值查找每次区间减少为原来的$\sqrt{n}$，因此时间复杂度变为$log(logn)$，在实际应用中，时间复杂度的改进并不明显，通常情况下，在大规模数组下，先使用差值查找缩小范围，中规模使用二分查找，小规模使用顺序查找。