（Week 2）二分法（C++）

已于 2022-11-07 21:39:53 修改
阅读量751 收藏
点赞数
分类专栏： NEUQACM作业 文章标签： c++ 算法
于 2022-11-07 21:39:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74036684/article/details/127739913
版权

目录

        1、P2249 【深基13.例1】查找（洛谷，C++，二分法）        

        2、进击的奶牛（洛谷，C++，二分法）

        3、[NOIP2015 提高组] 跳石头（洛谷，C++，二分法）

P2249 【深基13.例1】查找（洛谷，C++，二分法）

题目描述

输入n个不超过10^9 的单调不减的（就是后面的数字不小于前面的数字）非负整数a1，a2，...，an，然后进行m次询问。对于每次询问，给出一个整数q，要求输出这个数字在序列中第一次出现的编号，如果没有找到的话输出-1 。

输入格式

第一行 2个整数n和m，表示数字个数和询问次数。

第二行n个整数，表示这些待查询的数字。

第三行m个整数，表示询问这些数字的编号，从 11 开始编号。

输出格式

输出一行，m个整数，以空格隔开，表示答案。

输入样例

11 3
1 3 3 3 5 7 9 11 13 15 15
1 3 6

输出样例

1 2 -1

说明/提示

数据保证，1 <= n <= 10^6，0 <= ai，q <= 10^9，1 <= m <= 10^5

本题输入输出量较大，请使用较快的 IO 方式。

注：虽然这里要使用较快的IO方式，但是不能通过getline(cin, str)而只能通过减少I/O次数（如Input与Processed一同进行），因为每位数字都算作一个字符，占用的长度难以确认

解题思路：

核心解题思路：二分搜索

以下为简单的二分搜索的实现

#include <iostream>
using namespace std;
​
int main()
{
    int num_array[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int right = 9, left = 0, middle;
    int acquire;
    bool acquire_result = false;
    cin >> acquire;
    while (right >= left)
    {
        middle = (right + left) / 2;
        if (num_array[middle] == acquire)
        {
            acquire = true;
            break;
        }
        else if (num_array[middle] > acquire)
        {
            right = middle - 1;
        }
        else
        {
            left = middle + 1;
        }
    }
    if (acquire_result)
    {
        cout << "True" << endl;
    }
    else
    {
        cout << "False" << endl;
    }
    return 0;
}

采用IPO思路实现代码：

（1）I：

创建两个数组，分别用于存储n个数字和m次询问的结果

用for循环输入n个数字

（2）P和O：

用for循环询问m次，每次得到的结果存储到数组中，统一输出

每次循环键入一个值，用二分法搜索

搜索到指定值以后，再次用while循环调用内层二分法，以确保得到最早出现的位置

代码实现如下：

#include <iostream>
using namespace std;
​
//考虑到边界条件，前后各留出一个冗余位
int num_array[int(1e6) + 1 + 1] = { -1 };//n个数字
int num_array_q[int(1e5) + 1] = { -1 };//m次询问结果
​
int main()
{
    int n, m;
    int i, j, z, middle;//循环和二分控制符
    int pos;//获取最早出现位置，若未搜索到，则为-1
    std::cin.tie(nullptr);
    cin >> n >> m;
    for (i = 1; i <= n; i++)//循环输入n个数字
    {
        cin >> num_array[i];
    }
    for (z = 1; z <= m; z++)//循环进行m次询问
    {
        cin >> num_array_q[z];
        //二分搜索开始
        i = 1, j = n, pos = -1;
        while (i <= j)
        {
            middle = (i + j) / 2;
            if (num_array[middle] == num_array_q[z])
            {
                while (num_array_q[z] == num_array[middle - 1])//while循环条件：只要middle的左侧仍有相同元素，就继续二分查找
                {
                    int inner_j = middle - 1;//内层二分的右
                    int inner_middle;//内层二分的middle
                    while (i <= inner_j)
                    {
                        inner_middle = (i + inner_j) / 2;
                        if (num_array[inner_middle] == num_array_q[z])
                        {
                            middle = inner_middle;
                            break;//找到内层middle，赋值给外层middle，退出，进入下一轮内层二分
                        }
                        else if (num_array[inner_middle] > num_array_q[z])
                        {
                            inner_j = inner_middle - 1;
                        }
                        else
                        {
                            i = inner_middle + 1;
                        }
                    }
                }
                pos = middle;
                break;
            }
            else if (num_array[middle] > num_array_q[z])
            {
                j = middle - 1;
            }
            else
            {
                i = middle + 1;
            }
        }
        cout << pos << ' ';
    }
    return 0;
}

进击的奶牛（洛谷，C++，二分法）

（开篇预警：本文是初学者所写，我自己对代码的简洁性都感到不满意，可以选择是否继续看，但注释很多，可读性应该不会特别差）

题目描述

Farmer John 建造了一个有N(2<=N<=100000)个隔间的牛棚，这些隔间分布在一条直线上，坐标是x1, ..., xN(0<=xi<=1000000000)

他的C(2<=C<=N) 头牛不满于隔间的位置分布，它们为牛棚里其他的牛的存在而愤怒。为了防止牛之间的互相打斗，Farmer John 想把这些牛安置在指定的隔间，所有牛中相邻两头的最近距离越大越好。那么，这个最大的最近距离是多少呢？

输入格式

第 1 行：两个用空格隔开的数字N和C。

第 2 ~ N+1 行：每行一个整数，表示每个隔间的坐标。

输出格式

输出只有一行，即相邻两头牛最大的最近距离。

样例 #1

样例输入 #1

5 3
1 
2 
8 
4 
9

样例输出 #1

3

解题思路：

核心解题思路1：由于目标值（最短距离的最大值）有范围限制，故用二分法搜索

范围限制：牛之间的间隔要尽可能的大，但间隔越大，所需要的牛棚数目越多，而牛棚数目是有限的

i = 1, j = integer_vector[N - 1];
    while (i <= j)//二分法寻找最大距离
    {
        middle = (i + j) / 2;
        index = is_accommodate(middle);
        if (index == 0)//容纳不下
        {
            j = middle - 1;
        }
        else if (index == 2)//位置剩余
        {
            i = middle + 1;
        }
        else//刚好可以（未必找到最大距离，可能有多个距离刚好可以，故不一定可以找到最大的最小距离）
        {
            while (is_accommodate(middle))//用以确保找到最大最小距离
            {
                middle++;
            }
            break;
        }
        //5 5
        //10 30 31 52 73 94
        //这组样例对于20和21均“刚好可以”
        //如果先尝试的是20，则max_min_dist为20，反之，则为21，而只有21才能符合题意
    }

核心解题思路2：将一头牛放在第一个牛棚，然后来到第二个牛棚，检查是否符合distance，符合则再放入一头牛，不符合则前往第三个牛棚，依次类推

int is_accommodate(int distance)//检测distance所符合的情形：0为空间不足，1为恰好容纳，2为空间冗余
{
    temp_max_min_dist = 1e9;//对于每个distance，都应该初始化temp_max_min_dist
    int i;//循环控制符
    //第一个位置直接放入一头牛
    int sum_dist = -1 * integer_vector[0];//用于判断是否>=distance
    int temp_c = C - 1;//用于判断是否可以容纳
    for (i = 2; i <= N; i++)//从第二个位置开始遍历
    {
        if (sum_dist + integer_vector[i - 1] >= distance)//判断是否符合距离条件
        {
            temp_c--;//放入一头牛
            if (temp_max_min_dist > sum_dist + integer_vector[i - 1])//寻找本轮的临时最大最小距离
            {
                temp_max_min_dist = sum_dist + integer_vector[i - 1];
            }
            sum_dist = -1 * integer_vector[i - 1];//放入一头牛后，再次初始化
            if (temp_c == 0)//牛全部放入，退出循环
            {
                break;
            }
        }
    }
    //退出循环只有两种情形：一是temp_c == 0，二是i == N + 1退出
    if (temp_c == 0)//找到牛可以全部放入的一种情形
    {
        max_min_dist = temp_max_min_dist;//不进行任何判断直接赋值是因为：越是靠后出现的值，就是越接近要求的值
        if (i == N)//空间刚好用尽
        {
            return 1;
        }
        else//空间冗余
        {
            return 2;
        }
    }
    else//空间不足
    {
        return 0;
    }
}

核心解题思路3：既然要从第一个牛棚开始依次遍历，那么所有牛棚的坐标就要有顺序（直接用sort()的话，可以直接跳过这一条），故需要排序算法，这里仍然采用二分法，搜索并插入，每键入一个坐标就要搜索和插入一次，因为二分法搜索的对象一定是有序的

注：由于需要频繁的插入的同时支持随机访问，故选择了vector容器

//键入坐标，同时进行二分法排序（升序）
    //前两个个元素单独处理
    cin >> temp_distance;
    integer_vector.push_back(temp_distance);
    cin >> temp_distance;
    if (temp_distance >= integer_vector[0])
    {
        integer_vector.push_back(temp_distance);
    }
    else
    {
        integer_vector.insert(integer_vector.begin(), temp_distance);
    }
    for (i = 3; i <= N; i++)
    {
        cin >> temp_distance;
        //确保temp_distance在二分查找的范围内
        if (temp_distance >= integer_vector[integer_vector.size() - 1])
        {
            integer_vector.push_back(temp_distance);
            continue;
        }
        else if (temp_distance <= integer_vector[0])
        {
            integer_vector.insert(integer_vector.begin(), temp_distance);
            continue;
        }
        index = false;//初始化开关状态
        left = 0, right = integer_vector.size() - 1;//初始化左和右
        while (right + 1 != left)//左和右不相邻，则继续
        {
            middle = (right + left) / 2;
            if (integer_vector[middle] == temp_distance)
            {
                integer_vector.insert(integer_vector.begin() + middle, temp_distance);
                index = true;//开关状态改变
                break;
            }
            else if (integer_vector[middle] > temp_distance)
            {
                right = middle - 1;
            }
            else
            {
                left = middle + 1;
            }
        }
        if (!index)
        {
            integer_vector.insert(integer_vector.begin() + left, temp_distance);
        }
    }
    //for (vector<int>::iterator it = integer_vector.begin(); it != integer_vector.end(); it++)
    //{
    //  cout << *it << endl;
    //}//输出排序结果测试

完整的代码实现如下：

#include <iostream>
#include <vector>
using namespace std;
​
int N, C;//牛棚数目、牛的数目
int max_min_dist = 1e9;//最终的最小距离的最大值
int temp_max_min_dist = 0;//每轮最小距离的最大值
vector<int> integer_vector;//用于存储键入的牛棚坐标
​
int is_accommodate(int distance)//检测distance所符合的情形：0为空间不足，1为恰好容纳，2为空间冗余
{
    temp_max_min_dist = 1e9;//对于每个distance，都应该初始化temp_max_min_dist
    int i;//循环控制符
    //第一个位置直接放入一头牛
    int sum_dist = -1 * integer_vector[0];//用于判断是否>=distance
    int temp_c = C - 1;//用于判断是否可以容纳
    for (i = 2; i <= N; i++)//从第二个位置开始遍历
    {
        if (sum_dist + integer_vector[i - 1] >= distance)//判断是否符合距离条件
        {
            temp_c--;//放入一头牛
            if (temp_max_min_dist > sum_dist + integer_vector[i - 1])//寻找本轮的临时最大最小距离
            {
                temp_max_min_dist = sum_dist + integer_vector[i - 1];
            }
            sum_dist = -1 * integer_vector[i - 1];//放入一头牛后，再次初始化
            if (temp_c == 0)//牛全部放入，退出循环
            {
                break;
            }
        }
    }
    //退出循环只有两种情形：一是temp_c == 0，二是i == N + 1退出
    if (temp_c == 0)//找到牛可以全部放入的一种情形
    {
        max_min_dist = temp_max_min_dist;//不进行任何判断直接赋值是因为：越是靠后出现的值，就是越接近要求的值
        if (i == N)//空间刚好用尽
        {
            return 1;
        }
        else//空间冗余
        {
            return 2;
        }
    }
    else//空间不足
    {
        return 0;
    }
}
​
int main()
{
    int i, j;//循环控制符
    int index;//分支控制开关
    int temp_distance;//用于读入距离
    cin >> N >> C;//键入牛棚和牛的数量
    integer_vector.reserve(N);//预留capacity，防止反复开辟浪费时间
    int right, left, middle;//用于二分操作的右和左和中
    //键入坐标，同时进行二分法排序（升序）
    //前两个个元素单独处理
    cin >> temp_distance;
    integer_vector.push_back(temp_distance);
    cin >> temp_distance;
    if (temp_distance >= integer_vector[0])
    {
        integer_vector.push_back(temp_distance);
    }
    else
    {
        integer_vector.insert(integer_vector.begin(), temp_distance);
    }
    for (i = 3; i <= N; i++)
    {
        cin >> temp_distance;
        //确保temp_distance在二分查找的范围内
        if (temp_distance >= integer_vector[integer_vector.size() - 1])
        {
            integer_vector.push_back(temp_distance);
            continue;
        }
        else if (temp_distance <= integer_vector[0])
        {
            integer_vector.insert(integer_vector.begin(), temp_distance);
            continue;
        }
        index = false;//初始化开关状态
        left = 0, right = integer_vector.size() - 1;//初始化左和右
        while (right + 1 != left)//左和右不相邻，则继续
        {
            middle = (right + left) / 2;
            if (integer_vector[middle] == temp_distance)
            {
                integer_vector.insert(integer_vector.begin() + middle, temp_distance);
                index = true;//开关状态改变
                break;
            }
            else if (integer_vector[middle] > temp_distance)
            {
                right = middle - 1;
            }
            else
            {
                left = middle + 1;
            }
        }
        if (!index)
        {
            integer_vector.insert(integer_vector.begin() + left, temp_distance);
        }
    }
    //for (vector<int>::iterator it = integer_vector.begin(); it != integer_vector.end(); it++)
    //{
    //  cout << *it << endl;
    //}//输出排序结果测试
    i = 1, j = integer_vector[N - 1];
    while (i <= j)//二分法寻找最大距离
    {
        middle = (i + j) / 2;
        index = is_accommodate(middle);
        if (index == 0)//容纳不下
        {
            j = middle - 1;
        }
        else if (index == 2)//位置剩余
        {
            i = middle + 1;
        }
        else//刚好可以（未必找到最大距离，可能有多个距离刚好可以，故不一定可以找到最大的最小距离）
        {
            while (is_accommodate(middle))//用以确保找到最大最小距离
            {
                middle++;
            }
            break;
        }
        //5 5
        //10 30 31 52 73 94
        //这组样例对于20和21均“刚好可以”
        //如果先尝试的是20，则max_min_dist为20，反之，则为21，而只有21才能符合题意
    }
    cout << max_min_dist << endl;
    return 0;
}

[NOIP2015 提高组] 跳石头（洛谷，C++，二分法）

题目背景

一年一度的“跳石头”比赛又要开始了!

题目描述

这项比赛将在一条笔直的河道中进行，河道中分布着一些巨大岩石。组委会已经选择好了两块岩石作为比赛起点和终点。在起点和终点之间，有N块岩石（不含起点和终点的岩石）。在比赛过程中，选手们将从起点出发，每一步跳向相邻的岩石，直至到达终点。

为了提高比赛难度，组委会计划移走一些岩石，使得选手们在比赛过程中的最短跳跃距离尽可能长。由于预算限制，组委会至多从起点和终点之间移走M块岩石（不能移走起点和终点的岩石）。

输入格式

第一行包含三个整数L, M, N，分别表示起点到终点的距离，起点和终点之间的岩石数，以及组委会至多移走的岩石数。保证L>=1且N >= M >= 0。

接下来 N 行，每行一个整数，第 i 行的整数 D_i( 0 < D_i < L)， 表示第 i 块岩石与起点的距离。这些岩石按与起点距离从小到大的顺序给出，且不会有两个岩石出现在同一个位置。

输出格式

一个整数，即最短跳跃距离的最大值。

样例 #1

样例输入 #1

25 5 2 
2
11
14
17 
21

样例输出 #1

4

提示

输入输出样例 1 说明

将与起点距离为 2和 14 的两个岩石移走后,最短的跳跃距离为 4(从与起点距离 17 的岩石跳到距离 21 的岩石,或者从距离 21 的岩石跳到终点)。

数据规模与约定

对于 20% 的数据，0 <= M <= N <= 10。 对于 50% 的数据，0 <= M <= N <= 100。 对于 100%的数据，0 <= M <= N <= 50000,1 <= L <= 10^9。

解题思路：

核心解题思路1：因为目标值（最短跳跃距离的最大值）有一个限定范围，故可以采用二分法搜索

限定范围：distance要尽可能的大，但distance越大，移除石头数目就越多，而移除石头的数目又不能超过M

//二分法（红蓝）
    int left = 0, middle, right = L + 1;
    while (left + 1 != right)
    {
        middle = (left + right) / 2;
        if (judge(middle))//返回值为真，继续尝试更大距离
        {
            ans = middle;
            left = middle;
        }
        else//返回值为假，需要缩短距离
        {
            right = middle;
        }
    }

核心解题思路2：站在起点上，观察下一块石头，若该石头不符合distance，则移除，否则站在这块石头上，再观察下一块石头，以此类推

bool judge(int distance)
{
    int sum = 0;
    int head = stone_array[0];
    for (int step = 1; step <= N; step++)//终点石头不能移动，故最后step到N即可
    {
        if (stone_array[step] - head < distance)
        {
            sum++;
        }
        else
        {
            head = stone_array[step];
        }
    }
    if (sum <= M)
    {
        return true;
    }
    else
    {
        return false;
    }
}
​
​

但这段代码只能符合两个条件中的一个，第二个条件不能满足，是因为最后第N块石头到终点的距离无法保证符合distance

解决方法就是加上一个简单的判断

while (L - stone_array[temp_N] < distance)//只要第N块石头到终点的距离不符合distance，就temp_N--
    {
        sum++;
        temp_N--;
    }

最后，完整代码如下：

#include <iostream>
#include <list>
using namespace std;
​
int L, N, M;//分别表示起点到终点的距离（终点坐标），起点和终点之间的岩石数，以及组委会至多移走的岩石数
int stone_array[50000 + 2];
​
bool judge(int distance)
{
    int temp_N = N;
    int sum = 0;
    int head = stone_array[0];
    while (L - stone_array[temp_N] < distance)
    {
        sum++;
        temp_N--;
    }
    for (int step = 1; step <= temp_N; step++)
    {
        if (stone_array[step] - head < distance)
        {
            sum++;
        }
        else
        {
            head = stone_array[step];
        }
    }
    if (sum <= M)
    {
        return true;
    }
    else
    {
        return false;
    }
}
​
int main()
{
    int ans = 0;
    cin >> L >> N >> M;
    stone_array[0] = 0;
    for (int i = 1; i <= N; i++)
    {
        cin >> stone_array[i];
    }
    stone_array[N + 1] = L;
    //二分法（红蓝）
    int left = 0, middle, right = L + 1;
    while (left + 1 != right)
    {
        middle = (left + right) / 2;
        if (judge(middle))
        {
            ans = middle;
            left = middle;
        }
        else
        {
            right = middle;
        }
    }
    cout << ans << endl;
    return 0;
}
WitheredSakura_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++二分法在数组中查找关键字的方法
09-03
主要介绍了C++二分法在数组中查找关键字的方法,涉及C++数组查找算法的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
C++版二分法查找算法
10-17
class binary_search { public: int * arr; int nElems; public : binary_search(); binary_search(int max); virtual ~binary_search(); int find(int searchKey); void insert(int value);...
Leetcode 502. IPO C++
weixin_43750513的博客
07-14 237
Leetcode 502. IPO 题目 假设 力扣（LeetCode）即将开始其 IPO。为了以更高的价格将股票卖给风险投资公司，力扣 希望在 IPO 之前开展一些项目以增加其资本。 由于资源有限，它只能在 IPO 之前完成最多 k 个不同的项目。帮助 力扣 设计完成最多 k 个不同项目后得到最大总资本的方式。 给定若干个项目。对于每个项目 i，它都有一个纯利润 Pi，并且需要最小的资本 Ci 来启动相应的项目。最初，你有 W 资本。当你完成一个项目时，你将获得纯利润，且利润将被添加到你的总资本中。 总而
矩阵乘法（C++）
热门推荐
m0_74036684的博客
10-30 1万+
一般难度的for循环应用，是典型线性代数例题
C++学习笔记——二分算法
最新发布
z0816208的博客
03-17 277
二分查找（Binary Search）是一种在中查找特定元素的算法。它的基本思想是每次将待查找区间缩小一半，通过比较中间元素和目标元素的大小关系来确定下一步查找的方向。这样可以快速地定位目标元素的位置。具体步骤：1、确定查找范围的左右边界，初始时左边界为0，右边界为2、计算中间位置 mid=(left+right)/2，并取整，这个位置将待查找区间分成两个部分。4、重复以上两个步骤，直到找到目标值或者目标值不存在（左边界大于右边界）。
漏字文（C++）
m0_74036684的博客
10-31 158
漏字文就是一段文字，其中的所有单词包含的字母的种类小于26，通过只存储单词的属性来简化代码的实现
【LeetCode 502】IPO
盛夏光年
02-27 258
一、题目描述 假设 LeetCode 即将开始其 IPO。为了以更高的价格将股票卖给风险投资公司，LeetCode希望在 IPO 之前开展一些项目以增加其资本。 由于资源有限，它只能在 IPO 之前完成最多 k 个不同的项目。帮助 LeetCode 设计完成最多 k 个不同项目后得到最大总资本的方式。 给定若干个项目。对于每个项目 i，它都有一个纯利润 Pi，并且需要最小的资本 Ci 来启动相应的...
【Leetcode】502.IPO（困难）
明朗晨光的专栏
07-23 148
贪心算法求解做项目的最大收益；优先队列中的元素为指针的时候的排序
二分法.zip_C++_二分法_二分法查找vc++
07-15
二分查找实现，修改上下界缩小范围获得正确答案
C++实现二分法求连续一元函数根
12-17
本文实例为大家分享了C++实现二分法求连续一元函数根的具体代码，供大家参考，具体内容如下 设计一个用二分法求连续一元函数根的通用函数solve 此函数有三个参数： 第一个是函数指针，指向所要求根的连续函数 第二...
数值分析二分法C++程序
05-12
数值分析二分法数值分析二分法数值分析二分法
疯狂星期四（C++）
m0_74036684的博客
10-30 920
用C++实现一个判断当前是周几的简单功能，考察了闰年判断算法等知识点
LeetCode 502. IPO (贪心算法)
Amxrjgcs的博客
06-03 252
IPO 贪心算法
排列（C++）
m0_74036684的博客
10-31 111
核心解题思路：利用逻辑上操作而不实际操作来简化代码
502. IPO
The Shawshank Redemption
09-08 209
502. IPO 难度困难114 假设 力扣（LeetCode）即将开始IPO。为了以更高的价格将股票卖给风险投资公司，力扣 希望在 IPO 之前开展一些项目以增加其资本。 由于资源有限，它只能在 IPO 之前完成最多k个不同的项目。帮助 力扣 设计完成最多k个不同项目后得到最大总资本的方式。 给你n个项目。对于每个项目i，它都有一个纯利润profits[i]，和启动该项目需要的最小资本capital[i]。 最初，你的资本为w。当你完成一个项目时，你将获得纯利润，且...
原神生日会（C++，入座不相邻问题）
m0_74036684的博客
10-31 695
简单的入座不相邻问题，核心解题思路为紧邻空位或者派蒙的座位上安排人数更多的一类旅行者
二分法的应用-C++
ymhdt的博客
03-28 1476
二分法是典型的分治算法。 我们使用二分法通常的目的是为了减小遍历规模。假如求解一个问题，本来需要遍历整个数组，得到结果。但是由于数组的特殊性或问题的特殊性，我们能够排除一半的错误结果不需要遍历，这就是二分法的使用逻辑。 一般，二分法会把一个时间复杂度为O(n) 的算法缩减为复杂度O(log n) 下面使用二分法求解几个问题： 1、问题：在一个有序数组中，找某个指定数值是否存在。 解：要求解特定值，假设特定值为A。由于数组有序，我们可以先求数组的中间位置的值B，如果A>B,则说明A在B的右
必刷算法题之二分查找（题目及代码）---C++
qq_40077565的博客
04-04 3028
本文给出的题目不限于二分查找，但是为了巩固二分查找的知识，只给出了二分查找的方法。 文章目录第1题：二分查找（704）第2题：二分查找（704）第3题：找出数组排序后的目标下标
C++——二分法
m0_48748418的博客
05-16 1456
如果中间元素等于目标元素，那么查找成功，返回中间位置。如果中间元素大于目标元素，说明目标元素可能在左半部分，更新结束位置为中间位置减1。如果中间元素小于目标元素，说明目标元素可能在右半部分，更新起始位置为中间位置加1。它的基本思想是将查找范围逐渐缩小一半，直到找到目标元素或确定目标元素不存在。如果目标元素不存在于列表中，那么在某个时刻，起始位置将大于结束位置，此时可以确定目标元素不存在。的函数，它接受一个有序整数数组和一个目标元素作为输入，并返回目标元素在数组中的索引。如果目标元素不存在，函数返回-1。
递归实现二分法c++
12-02
以下是递归实现二分法的C++代码示例： ```c++ #include using namespace std; int binarySearch(int arr[], int start, int ends, int target) { if (ends >= start) { int mid = start + (ends - start) 2; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WitheredSakura_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值