C/C++：二分法查找

最新推荐文章于 2024-05-16 08:53:55 发布
最新推荐文章于 2024-05-16 08:53:55 发布
阅读量589 收藏 4
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45034316/article/details/118390833
版权

二分法查找

#include <iostream>
#include <cstdio>
using namespace std;

// a是有序数组（从小到大排序），length是数组长度，num是指定元素
int BinarySearch(int a[], int length, int num)
{
    // 初始查找区间：[0, length-1]
    int L = 0;  // 查找区间的左端点
    int R = length - 1;  // 查找区间的右端点

    while(L <= R) {  // 如果查找区间不为空，就继续查找
        int mid = L + (R - L) / 2;  // 查找区间的中间值
        // int mid = (L + R) / 2;  // L+R的值可能过大导致溢出，因此不使用该语句
        // cout << "L = " << L << ", R = " << R << ", mid = " << mid << endl;

        if(num > a[mid]) {  // 如果num在a[mid]的右边
            // 设置新的查找区间：[mid+1, R]
            L = mid + 1;
        }
        else if(num < a[mid]) {  // 如果p在a[mid]的左边
            // 设置新的查找区间：[L, mid-1]
            R = mid - 1;
        }
        else {  // 如果正好找到，返回下标
            return mid;
        }
    }
    return -1;  // 如果没有找到，返回-1
}

int main()
{
    // 在有序数组a中查找指定元素num的下标
    int a[10] = {2, 6, 11, 23, 32, 44, 51, 73, 90, 108};  // 有序数组
    int length = sizeof(a) / sizeof(int);  // 数组长度
    int num = 23;  // 指定元素

    int r = BinarySearch(a, length, num);
    if(r < 0)  // 如果没有找到
        cout << "No Found." << endl;
    else
        cout << "Index of " << a[r] << " is " << r << endl;
    
    return 0;
}

例题：找一对数

问题：输入 n(n≤100,000) 个整数，找出其中的两个数，它们的和等于整数 m（假定肯定有解）。

解法1：用两重循环，枚举所有的取数方法，复杂度是 O(n2)。

#include <iostream>
#include <cstdio>
using namespace std;

int main()
{
    int n, m;
    cout << "Input n: "; cin >> n;  // 数组长度
    cout << "Input m: "; cin >> m;  // 两个数的和
    int a[n];
    cout << "Input array: ";
    for(int i = 0; i < n; i++) {  // 输入n个整数作为无序数组的元素
        cin >> a[i];
    }

    for(int i = 0; i < n; i++) {  // 循环遍历第一个数
        for(int j = i + 1; j < n; j++) {  // 循环遍历第二个数
            if(a[i] + a[j] == m) {  // 如果这两个数正好符合条件
                cout << a[i] << ", " << a[j] << endl;
                break;
            }
        }
    }

    return 0;
}

解法2：将数组排序，复杂度是 O(n×log(n))。对数组中的每个元素 a[i]，用二分法查找 m-a[i]，复杂度是 O(n×log(n))。总的复杂度是 O(n×log(n))。

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

// a是有序数组（从小到大排序），length是数组长度，num是指定元素
int BinarySearch(int a[], int length, int num)
{
    int L = 0;  // 查找区间的左端点
    int R = length - 1;  // 查找区间的右端点
    while(L <= R) {  // 如果查找区间不为空，就继续查找
        int mid = L + (R - L) / 2;  // 查找区间的中间值
        if(num > a[mid])  // 如果num在a[mid]的右边
            L = mid + 1;
        else if(num < a[mid])  // 如果p在a[mid]的左边
            R = mid - 1;
        else  // 如果正好找到，返回下标
            return mid;
    }
    return -1;  // 如果没有找到，返回-1
}

int main()
{
    int n, m;
    cout << "Input n: "; cin >> n;  // 数组长度
    cout << "Input m: "; cin >> m;  // 两个数的和
    int a[n];
    cout << "Input array: ";
    for(int i = 0; i < n; i++) {  // 输入n个整数作为无序数组的元素
        cin >> a[i];
    }

    sort(a, a+n);  // 将数组排序
    for(int i = 0; i < n; i++) {  // 循环遍历第一个数
        int j = BinarySearch(a, n, m-a[i]);  // 用二分法查找第二个数
        if(j >= 0) {  // 如果查找结果不为-1，即找到第二个数
            cout << a[i] << ", " << a[j] << endl;
            break;
        }
    }

    return 0;
}

解法3：将数组排序，复杂度是 O(n×log(n))。设置两个变量 i 和 j 进行查找，i 的初值是0，j 的初值是 n-1，计算 a[i]+a[j]，如果大于 m 则 j-1，如果小于 m 则 i+1，直到等于 m，复杂度是 O(n)。总的复杂度是 O(n×log(n))。

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

// a是有序数组（从小到大排序），length是数组长度，num是指定元素
int BinarySearch(int a[], int length, int num)
{
    int L = 0;  // 查找区间的左端点
    int R = length - 1;  // 查找区间的右端点
    while(L <= R) {  // 如果查找区间不为空，就继续查找
        int mid = L + (R - L) / 2;  // 查找区间的中间值
        if(num > a[mid])  // 如果num在a[mid]的右边
            L = mid + 1;
        else if(num < a[mid])  // 如果p在a[mid]的左边
            R = mid - 1;
        else  // 如果正好找到，返回下标
            return mid;
    }
    return -1;  // 如果没有找到，返回-1
}

int main()
{
    int n, m;
    cout << "Input n: "; cin >> n;  // 数组长度
    cout << "Input m: "; cin >> m;  // 两个数的和
    int a[n];
    cout << "Input array: ";
    for(int i = 0; i < n; i++) {  // 输入n个整数作为无序数组的元素
        cin >> a[i];
    }

    sort(a, a+n);  // 将数组排序
    int i = 0, j = n - 1;  // 用i从前往后查找，用j从后往前查找
    while(i < j) {
        if(a[i] + a[j] > m)  // 如果结果大于m
            j--;  // j应该往前移使结果减小
        else if(a[i] + a[j] < m)  // 如果结果小于m
            i++;  // i应该往后移使结果增大
        else {  // a[i] + a[j] == m
            cout << a[i] << ", " << a[j] << endl;
            break;
        }
    }

    return 0;
}

输入：
n = 10，m = 50，a[n] = {11, 54, 23, 32, 44, 6, 10, 13, 2, 26}

输出：
在这里插入图片描述

例题：农夫和奶牛

问题：农夫建造了一座很长的畜栏，有 N(2≤N≤100,000) 个隔间，这些隔间的位置是 x0, x1, …, xN-1(0≤xi≤1,000,000,000)，xi 均为整数，各不相同。有 C(2≤C≤N) 头牛，每头牛分到一个隔间，如何使任意两头牛之间的最小距离尽可能大？这个最大的最小距离是多少？

解法1：将数组排序，得到排序后的隔间坐标 x[N]。从 1,000,000,000/C 到 1 依次尝试最大的最小距离 D，直到找到第一个可行的值，复杂度是 1,000,000,000/C×N。
尝试方法：第 1 头牛放在 x0，……若第 k 头牛放在 xi，则找到 xi+1 到 xN-1 中第一个位于 [Xi+D, 1,000,000,000] 的 xj，第 k+1 头牛放在 xj，如果找不到这样的 xj 则 D-1，继续尝试。

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

#define MaxXi 100  // xi的最大值

// 判断D是否可行
bool JudgeDis(int D, int N, int C, int x[], int cow[])
{
    cow[0] = 0;  // 第0号牛放在第0号隔间，隔间坐标是x[0]
    int i, j, k;
    for(k = 1; k < C; k++) {  // 对其余每头牛（第1~C-1号）分配隔间
        i = cow[k-1];  // 如果第k-1号牛放在第i号隔间，隔间坐标是x[i]
        for(j = i + 1; j < N; j++) {  // 从第i号隔间向后查找
            if(x[j] >= x[i] + D) {  // 如果找到符合条件的x[j]
                cow[k] = j;  // 第k号牛放在第j号隔间，隔间坐标是x[j]
                break;
            }
        }
        if(j == N)  // 如果找不到x[j]，即D不可行
            return false;
    }
    if(k == C)  // 如果所有牛都能放在隔间中，即D可行
        return true;
}

int main()
{
    int N, C;
    cout << "Input N: "; cin >> N;  // 隔间的数量
    cout << "Input C: "; cin >> C;  // 牛的数量
    int x[N];
    cout << "Input array: ";
    for(int i = 0; i < N; i++) {  // 输入N个隔间的位置或坐标
        cin >> x[i];
    }
    int cow[C];  // 牛的隔间序号

    sort(a, a+n);  // 将数组排序
    for(int D = MaxXi / C; D > 0; D--) {  // 尝试最大的最近距离
        if(JudgeDis(D, N, C, x, cow)) {  // 如果D可行
            cout << "Maximum nearest distance: " << D << endl;
            break;
        }
    }
    for(int i = 0; i < C; i++) {
        cout << "Cow number: " << i + 1 << ", Cow location: " << x[cow[i]] << endl;
    }
    
    return 0;
}

解法2：将数组排序，得到排序后的隔间坐标 x[N]。在 [L, R] 内用二分法尝试最大的最小距离 D=(L+R)/2，如果 D 可行则记录该 D 并且 L=D+1，如果 D 不可行则 R=D-1，复杂度是 log(1,000,000,000/C)×N。

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

#define MaxXi 100  // xi的最大值

// 判断D是否可行
bool JudgeDis(int D, int N, int C, int x[], int cow[])
{
    cow[0] = 0;  // 第0号牛放在第0号隔间，隔间坐标是x[0]
    int i, j, k;
    for(k = 1; k < C; k++) {  // 对其余每头牛（第1~C-1号）分配隔间
        i = cow[k-1];  // 如果第k-1号牛放在第i号隔间，隔间坐标是x[i]
        for(j = i + 1; j < N; j++) {  // 从第i号隔间向后查找
            if(x[j] >= x[i] + D) {  // 如果找到符合条件的x[j]
                cow[k] = j;  // 第k号牛放在第j号隔间，隔间坐标是x[j]
                break;
            }
        }
        if(j == N)  // 如果找不到x[j]，即D不可行
            return false;
    }
    if(k == C)  // 如果所有牛都能放在隔间中，即D可行
        return true;
}

int main()
{
    int N, C;
    cout << "Input N: "; cin >> N;  // 隔间的数量
    cout << "Input C: "; cin >> C;  // 牛的数量
    int x[N];
    cout << "Input array: ";
    for(int i = 0; i < N; i++) {  // 输入N个隔间的位置或坐标
        cin >> x[i];
    }
    int cow[C];  // 牛的隔间序号

    sort(a, a+n);  // 将数组排序
    int maxD;  // 最大的最近距离
    int cowD[C];  // 在找到最大的最近距离时的牛的间隔序号
    int L = 1, R = MaxXi / C;  // 二分法的初始区间
    while(L <= R) {  // 如果查找区间不为空，就继续尝试D
        int D = L + (R - L) / 2;
        if(JudgeDis(D, N, C, x, cow)) {  // 如果D可行
            maxD = D;  // 记录该D
            memcpy(cowD, cow, C*sizeof(int));  // 记录该D时的牛的间隔序号
            L = D + 1;
        }
        else {  // 如果D不可行
            R = D - 1;
        }
    }

    cout << "Maximum nearest distance: " << maxD << endl;
    for(int i = 0; i < C; i++) {
        cout << "Cow number: " << i + 1 << ", Cow location: " << x[cowD[i]] << endl;
    }

    return 0;
}

输入：
N = 10，C = 4，x[N] = {8, 2, 13, 87, 46, 39, 27, 31, 17, 5}

输出：
在这里插入图片描述

瑞瑞ruirui
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++二分查找（最全）
weixin_72909426的博客
10-04 1918
大家好！今天我们一起来学习C++之二分查找~~~有的人会说：“哎呀！我不理解什么叫二分查找呢！有的人会说：“我已经会了，为什么还要看这篇博客呢？没事，别着急，无论是会还是不会，这篇博客既可以帮不会的人学懂，也可以帮会的人复习，请不要划走！今天分为5个板块：1.什么叫“二分查找？2.“二分查找”的缺是什么？3.“二分查找”怎么实现？4.“二分查找”易错的地方在哪？5.今天的作业是什么？（下一篇博客讲解）
C++算法之二分查找
weixin_43994529的博客
08-06 8348
二分查找，又叫折半查找，因为二分查找每一次查找都可以缩减掉一半的查找范围。
最全【C++】二分查找--超详细图解（小白一看就懂，2024年最新成功收获美团，2024年最新小米offer
最新发布
2401_84973151的博客
05-16 1043
二分法最重要的两个点，就是循环条件和后续的区间赋值问题因为两者是相互联系，相互影响的，所以就需要两者统一，如果两者不统一，就会出现问题所以循环条件和赋值问题必须统一，也就是循环不变量。
【C++】二分查找--超详细图解（小白一看就懂！！！）
weixin_45031801的博客
04-07 3463
二分法的思想十分容易理解，但是二分法 - 边界 - 处理问题大多数人都是记忆模板，忘记模板后处理边界就一团乱（👁:“我懂了”， ✋ :"你懂个🔨"​）因为我此前也是记忆模板，所以现在想通过一边学习，一边将所学记录成博客进行复习（费曼学习法），希望以后能自己推导出边界如何处理，而不仅仅是记忆模板。欢迎一起交流学习，如有看法不一样之处也欢迎留言一起讨论！
c++二分查找
Yoyo的博客
01-08 1435
由于此时只剩下两个数了，所以我们不再二分了，直接判断A[8]是否等于17,或者A[9]是否等于17即可。//表示要在A[1]至A[N]范围查找x。因为我们要查找的数是3，小于A[mid]，所以我们下次要在A[L]至A[mid]范围内查找，//查询数组A是否包含x。因为要查找的数是17，大于A[5]，所以我们应该在A[5]至A[10]这一段查找，令L=1， R=10， 表示我们用在A[1],A[2],...A[10]里面查找。1、当要查找的数小于A[1]或者大于A[N]，返回"no"，否则进入二分查找过程。
【C++】C++11 STL算法(四)：二分查找法（Binary search operations）、合并操作
郭老二
11-27 1537
头文件：#include <algorithm> 一、lower_bound 1、原型： template< class ForwardIt, class T > ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value ); template< class ForwardI...
C++二分法在数组中查找关键字的方法
09-03
主要介绍了C++二分法在数组中查找关键字的方法,涉及C++数组查找算法的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
二分法检索查找 计算机算法 c/c++语言
12-31
二分法检索查找 计算机算法 c/c++语言
二分法查找某数的C语言程序
09-05
该资源用C语言写的，通俗易懂，用了很多基础的语法，缺点是没有把他编写成调用的函数
c/c++ 学习总结 初学者必备
09-16
(1)二分法查找; B:写出下列算法的时间复杂度和实现排序: (1)冒泡排序； (2)选择排序； (3)插入排序； (4)快速排序； (5)堆排序； (6)归并排序； 23、编写gbk_strlen函数,计算含有汉字的字符串的长度,汉字作为一...
二分查找（折半查找）简介与代码实现（C++）
GTC的博客
04-11 2380
二分查找（折半查找）简介与代码实现1.简介2.代码实现（C++）2.1.写法一（target在左闭右闭区间）2.2.写法二（target在左闭右开区间）3.代码检验 1.简介 二分查找的本质： 首先确定待查元素所在的范围，然后逐步缩小范围（区间），直到查找到元素或者查找失败为止。 二分查找的前提： 数组必须是有序的 2.代码实现（C++） 2.1.写法一（target在左闭右闭区间） 1.因为left与right相等的情况在[left，right]区间有意义，所以在while(left <=
二分查找法（C++实现）
CC_fighting的博客
05-18 1万+
二分查找法的思想非常简单，在一组已经完成排序的数据(array[])中，如果需要查找某一特定数据（value）是否存在的时候，设置两个上下限（max， min）开始的时候在数组的最前和最后，把需要查找的值跟这两个位置的中间位置数据(array[(max+min)/2])进行对比，如果value >array[(min+max)/2] ,则缩小范围使得min=(min+max)/2,反之，如果...
C/C++二分查找
qq_43142509的博客
09-20 1027
文章目录算法解释求开方查找区间旋转数组查找数字总结 算法解释 二分查找也常被称为二分法或者折半查找，每次查找时通过将待查找区间分成两部分并只取一部分继续查找，将查找的复杂度大大减少。对于一个长度为 O(n) 的数组，二分查找的时间复杂度为 O(log n)。 举例来说，给定一个排好序的数组 {3,4,5,6,7}，我们希望查找 4 在不在这个数组内。第一次折半时考虑中位数 5，因为 5 大于 4, 所以如果 4 存在于这个数组，那么其必定存在于 5 左边这一半。于是我们的查找区间变成了 {3,4,5}。.
C++实现二分法详解
厦门在乎科技
07-08 4806
二分法是在一个排好序的序列（数组，链表等）中，不断收缩区间来进行目标值查找的一种算法，下面我们就来探究二分法使用的一些细节，以及常用的场景： 寻找一个数； 寻找左侧边界； 寻找右侧边界。一、二分法的通用框架 int binarySearch(vector<int>& nums, int target){ int left=0, right=nums.size(); while(left < right) { int mid=(left+
c++实现二分查找
07-14 671
简要描述 二分查找又称折半查找，对排好序的数组，每次取这个数和数组中间的数进行比较，复杂度是O(logn)如:设数组为a[n],查找的数x, 如果x==a[n/2]，则返回n/2; 如果x<a[n/2]，则在a[0]到a[n/2-1]中进行查找； 如果x>a[n/2]，则在a[n/2+1]到a[n-1]中进行查找； 优点是比较次数少，查找速度快，平均性能好；其缺点是要求...
二分法c++代码
sun13047140038的博客
06-07 718
cout
C语言二分法查找法
热门推荐
魔鬼的步伐
08-19 5万+
C语言 == 二分查找法 == 所谓的二分查找法，其实是一种有序的查找方法，也称折半查找（Binary Search），如果是无序的则要先进行排序操作。基本思想是：目标值通过与中间元素比较，可分为三种情况： 第一种情况：目标值与中间元素相等，查找结束； 第二种情况：目标值比中间元素大，则把后半部分的中间元素与目标值比较； 第二种情况：目标值比中间元素小，则把前半部分的中间元素与目标值...
[C++]二分查找法
LynlinBoy的博客
11-24 544
引用：https://baike.baidu.com/item/%E4%BA%8C%E5%88%86%E6%B3%95/1364267?fr=aladdin 二分法 对于区间上连续不断且的函数，通过不断地把函数的零点所在的区间一分为二，使区间的两个端点逐步逼近零点，进而得到零点近似值的方法叫二分法。 定义 二分法（Bisection method） 即一分为二的方法. 设为R的闭区间...
[LeetCode]704.二分查找及相关题目
夜来疯的博客
10-09 339
数组理论基础 数组理论 数组是存放在连续内存空间上的相同类型数据的集合 数组可以方便的通过下标索引的方式获取到下标下对应的数据 二维数组在内存的空间地址是连续的 二分查找 LeetCode 704.二分查找 二分法使用前提: 有序元素 + 无重复元素 区间的定义 区间的定义就是不变量。要在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则。 二分法的区间定义分为两种 左闭右闭， [left,right] 1）while(
浮点数二分法查找c++
09-13
浮点数二分法是一种常用的算法，可以用来在有序的浮点数数组中查找特定的值。下面是一个示例的C代码实现： ```c #include <stdio.h> // 定义一个函数用于判断给定值是否满足条件 int check(double x) { // TODO: 根据实际需要进行修改 double target = 10.0; double diff = x - target; if (diff > 0.000001) { return 1; // x大于target } else if (diff < -0.000001) { return -1; // x小于target } else { return 0; // x等于target } } double binarySearch(double left, double right) { double mid; while (right - left > 0.000001) { mid = left + (right - left) / 2; int result = check(mid); if (result == 0) { return mid; // 找到目标值 } else if (result == 1) { right = mid; } else { left = mid; } } return left; // 没有找到目标值，返回左边界值 } int main() { double left = 0.0; // 数组左边界 double right = 100.0; // 数组右边界 double result = binarySearch(left, right); printf("Result: %lf\n", result); return 0; } ``` 在上面的代码中，`check()` 函数用于判断给定的值是否满足条件。你可以根据自己的需求修改该函数的具体实现。`binarySearch()` 函数使用二分法在给定的区间内查找目标值，并返回找到的结果。 请注意，上述代码仅为示例，实际使用时需要根据具体情况进行修改和适配。另外，浮点数比较存在精度问题，需要注意使用合适的比较范围来判断两个浮点数是否相等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值