ACM模板 - 二分查找（完整版）

Dream_Weave

已于 2022-06-04 10:17:20 修改

阅读量2.6k

点赞数 5

CC 4.0 BY-SA版权

分类专栏： # ACM 文章标签： ACM 二分查找折半查找 binary_search lower_bound

于 2018-05-25 16:38:25 首次发布

本文链接：https://blog.youkuaiyun.com/Dream_Weave/article/details/80453628

ACM 专栏收录该内容

47 篇文章

订阅专栏

本文详细解析了二分查找的不同变种，共计64种，并提供了针对不同问题的高效实现示例，包括寻找特定元素的位置及边界条件等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

64种。理由如下：
对其进行分类：
取整方式：向下取整向上取整（共2种）
区间开闭：闭区间左闭右开区间左开右闭区间开区间（共4种）
问题类型：
对于不下降序列a，求最小的i，使得a[i] = key
对于不下降序列a，求最大的i，使得a[i] = key
对于不下降序列a，求最小的i，使得a[i] > key
对于不下降序列a，求最大的i，使得a[i] < key
对于不上升序列a，求最小的i，使得a[i] = key
对于不上升序列a，求最大的i，使得a[i] = key
对于不上升序列a，求最小的i，使得a[i] < key
对于不上升序列a，求最大的i，使得a[i] > key
（共8种）
综上所述，二分查找共有 2*4*8=64 种写法。

算法的目的是解决问题，下面以针对不下降序列a的4个问题为例，给出我认为效率较高，较为简洁的代码。

对于不下降序列a，n为序列a元素的个数，key为关键字：

1.求最小的i，使得a[i] = key，若不存在，则返回-1

int binary_search_1(int a[], int n, int key)
{
    int m, l = 0, r = n - 1; // 闭区间[0, n - 1]
    while (l < r)
    {
        m = l + ((r - l) >> 1); // 向下取整
        if (a[m] < key) l = m + 1;
        else r = m;
    }
    if (a[r] == key) return r;
    return -1;
}

2.求最大的i，使得a[i] = key，若不存在，则返回-1

int binary_search_2(int a[], int n, int key)
{
    int m, l = 0, r = n - 1; // 闭区间[0, n - 1]
    while (l < r)
    {
        m = l + ((r + 1 - l) >> 1); // 向上取整
        if (a[m] <= key) l = m;
        else r = m - 1;
    }
    if (a[l] == key) return l;
    return -1;
}

3.求最小的i，使得a[i] > key，若不存在，则返回-1

int binary_search_3(int a[], int n, int key)
{
    int m, l = 0, r = n - 1;//闭区间[0, n - 1]
    while (l < r)
    {
        m = l + ((r - l) >> 1);//向下取整
        if (a[m] <= key) l = m + 1;
        else r = m;
    }
    if (a[r] > key) return r;
    return -1;
}

4.求最大的i，使得a[i] < key，若不存在，则返回-1

int binary_search_4(int a[], int n, int key)
{
    int m, l = 0, r = n - 1;//闭区间[0, n - 1]
    while (l < r)
    {
        m = l + ((r + 1 - l) >> 1);//向上取整
        if (a[m] < key) l = m;
        else r = m - 1;
    }
    if (a[l] < key) return l;
    return -1;
}

实际上，对于3、4，也可以先判断解是否存在，再进行二分查找。

显然，上面的代码还不够简洁。下面给出我认为最简洁的代码：

// 1.
int ans = std::lower_bound(a, a + n, key) - a;
ans = (ans == n || a[ans] != key) ? -1 : ans;

// 2.
int ans = std::upper_bound(a, a + n, key) - a;
ans = (ans == 0 || a[ans - 1] != key) ? -1 : ans - 1;

// 3.
int ans = std::upper_bound(a, a + n, key) - a;
ans = (ans == n) ? -1 : ans;

// 4.
int ans = std::lower_bound(a, a + n, key) - a;
ans = (ans == 0) ? -1 : ans - 1;