二分搜索法学习

文章参考：https://blog.csdn.net/yusiguyuan/article/details/48052659
https://www.cnblogs.com/grandyang/p/6854825.html

一、二分搜索法

在一个有序的数组中，查找一个数，可以使用二分查找。
比如代码：

//二分搜索法
int binary_search(int* array, int n, int key)
{
    int low = 0;
    int high = n - 1;
    int mid;
    if (high < low)
        return -1;
    while (high >= low)
    {
        mid = low + ((high - low) >> 1);
        if (array[mid] == key)
            return mid;
        else if (array[mid] > key)
            high = mid - 1;
        else
            low = mid + 1;
    }
    return -1;
}

但是对于上面的二分查找还有另外一种写法，这是写作习惯的问题：

如果high = n-1 => while(high>=low) => high = middle-1;

如果high = n  => while(high > low)  => high = middle;

二、二分搜索的变形

1）lower_bound 查找第一个不小于目标值的数

//lower_bound 查找第一个不小于目标值的数
int lower_bound(int* array, int low, int high, int key)
{
    int mid;
    if (high< low)
        return -1;
    while (high >= low)
    {
        mid = low + ((high - low) >> 1);
        if (array[mid] < key)
            low = mid + 1;
        else
            high = mid - 1;
        //cout<<mid<<endl;
    }
    return low;
}

比如在数组[2, 4, 5, 6, 9]中查找数字3，就会返回数字4的位置；在数组[0, 1, 1, 1, 1]中查找数字1，就会返回第一个数字1的位置。

2）查找第一个大于目标值的数

//查找第一个大于目标值的数
int upper_bound(int* array, int low, int high, int key)
{
    int mid;
    if (high < low)
        return -1;
    while (high >= low)
    {
        mid = low + ((high - low) >> 1);
        if (array[mid] > key)
            high = mid - 1;
        else
            low = mid + 1;
    }
    return low;
}

比如在数组[2, 4, 5, 6, 9]中查找数字3，还是返回数字4的位置，因为数字4在此数组中既是第一个不小于目标值3的数，也是第一个大于目标值3的数，所以make sense；在数组[0, 1, 1, 1, 1]中查找数字1，就会返回坐标5，通过对比返回的坐标和数组的长度，我们就知道是否存在这样一个大于目标值的数。

三、标准STL中lower_bound和upper_bound

在从小到大的排序数组中：

lower_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

upper_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个**大于**num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

#include <iostream>
#include <algorithm>//必须包含的头文件
using namespace std;

int main()
{
    int arr[] = { 2, 3, 3, 6, 9 };
    //第一个大于或等于num数字的位置
    cout << lower_bound(arr, arr + 5, 3) - arr << endl;  //1
    //第一个大于num数字的位置
    cout << upper_bound(arr, arr + 5, 3) - arr << endl;  //3
    getchar();
    return 0;
}

四、二分查找的递归非递归实现

以下整理了网上经典的二分查找的递归与非递归方法。

#include <iostream>
#include <cmath>
#include <cstring>
using namespace std;

//copyright@2011 July
//随时欢迎读者找bug，email：zhoulei0907@yahoo.cn。

//首先要把握下面几个要点：
//right=n-1 => while(left <= right) => right=middle-1;
//right=n   => while(left <  right) => right=middle;
//middle的计算不能写在while循环外，否则无法得到更新。

int binary_searchIteration(int array[], int n, int value)
{
    int left = 0;
    int right = n - 1;

    while (left <= right)          //循环条件，适时而变
    {
        int middle = left + ((right - left) >> 1);  
        //防止溢出，移位也更高效。同时，每次循环都需要更新。

        if (array[middle]>value)
        {
            right = middle - 1;   //right赋值，适时而变
        }
        else if (array[middle]<value)
        {
            left = middle + 1;
        }
        else
            return middle;
    }
    return -1;
}


int binary_searchRecursion(int arr[], int low, int high, int key) {
    if (low > high) return -1;

    int mid = (high + low) / 2;   //中间元素，防止溢出
    if (key == arr[mid])return mid; //找到时返回
    else if (key > arr[mid]) {
        return binary_searchRecursion(arr, mid + 1, high, key); 
        // 在更高的区间搜索
    }
    else {
        return binary_searchRecursion(arr, low, mid - 1, key); 
        // 在更低的区间搜索
    }
}


int main()
{
    int arr[] = { 2, 3, 3, 6, 9 };
    cout << binary_searchIteration(arr,5, 6) << endl;
    cout << binary_searchRecursion(arr, 0,5, 2) << endl;

    getchar();
    return 0;
}