经典算法 ——二分(找出指定数在数组中的范围)

经典算法 ——二分(找出指定数在数组中的范围)

链接:https://www.nowcoder.com/questionTerminal/3783c394c5d84d5ab9e55d91a6efeb8c?answerType=1&f=discussion

来源:牛客网

输入一个排好序的整数数组,找到指定目标数的开始和结束位置。如果指定的数字不在数组中,则输出 [-1,-1]。例如,输入数组为[5, 7, 7, 8, 8, 10], 目标数为8, 输出[3, 4].本题会人工判题,要求时间复杂度O(logn)

输入描述:

输入数据包括两行:

第一行两个整数n(1 ≤ n ≤ 10 ^ 5),和需要查找的数target

第二行n个整数,范围均在32位整数内,以空格分隔

输出描述:

输出格式为[begin,end],如果不存在就输出[-1,-1]

示例1

输入

6 8 5 7 7 8 8 10

输出

3 4

#include<iostream>
using namespace std;
int a[100010];//创建一个数组
int n;//数组中共有n个数
int target;//指定数
int main()
{
    
    cin>>n>>target;//输入n和指定数的值
    for(int i=0;i<n;i++) scanf("%d",&a[i]);//输入数组中的数
    int l=0,r=n-1;//数组的两个边界的下标
    while(l<r)
    {
        int mid=l+r>>1;//数组中间的下标
        if(a[mid]>=target) r=mid;//如果a[mid]在target的右侧,则改变数组的右边界
        else l=mid+1;//反之则改变数组的左边界
    }
    if(a[l]!=target)cout<<"[-1,-1]"<<endl;//l下标的数应是target,如果不是,那么在这个数组中就没有这个数
    else 
    {
        cout<<"["<<l;//输出l的值,l是范围的最左侧的下标
        int l=0,r=n-1;
        while(l<r)
        {
            int mid=l+r+1>>1;//为什么和第一次相比加了一个1呢?这是因为如果这个数组只有两个数的话,将会出现死循环,这其实是由后面的if语句造成的,如果a[mid]=target的时候l=mid,那么就是这个地方要加一了
            if(a[mid]<=target) l=mid;//原因同上一次
            else r=mid-1;//原因同上一次
        }
        cout<<l<<"]"<<endl;//输出范围的最右端
    }
    return 0;
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
主要讲述了计算机系统的开发领域。在每章中的漂亮代码都是来自独特解决方案的发现,而这种发现是来源于作者超越既定边界的远见卓识,并且识别出被多数人忽视的需求以及找出令人叹为观止的问题解决方案。 本书介绍了人类在一个奋斗领域中的创造性和灵活性:计算机系统的开发领域。在每章中的漂亮代码都是来自独特解决方案的发现,而这种发现是来源于作者超越既定边界的远见卓识,并且识别出被多数人忽视的需求以及找出令人叹为观止的问题解决方案。 本书33章,有33位作者,每位作者贡献一章。每位作者都将自己心目中对于“美丽的代码”的认识浓缩在一章当中,张力十足。33位大师,每个人对代码之美都 有自己独特的认识,现在一览无余的放在一起,对于热爱程序的每个人都不啻一场盛宴。 虽然本书的涉猎范围很广,但也只能代表一小部分在这个软件开发这个最令人兴奋领域所发生的事情。 本书收录的是软件设计领域中的一组大师级作品。每一章都是由一位或几位著名程序员针对某个问题给出的完美的解决方案,并且细述了这些解决方案的巧妙之处。 本书既不是一本关于设计模式的书,也不是一本关于软件工程的书,它告诉你的不仅仅是一些正确的方式或者错误的方式。它让你站在那些优秀软件设计师的肩膀上,从他们的角度来看待问题。 本书给出了38位大师级程序员在项目设计中的思路、在开发工作中的权衡,以及一些打破成规的决策。 第1章 正则表达式匹配器 。 1.1 编程实践 1.2 实现 1.3 讨论 1.4 其他的方法 1.5 构建 1.6 小结 第2章 Subversion中的增量编辑器:像本体一样的接口 2.1 版本控制与目录树的转换 2.2 表达目录树的差异 2.3 增量编辑器接口 2.4 但这是不是艺术? 2.5 像体育比赛一样的抽象 2.6 结论 第3章 我编写过的最漂亮代码 3.1 我编写过的最漂亮代码 3.2事倍功半 3.3 观点 3.4 本章的中心思想是什么? 3.5 结论 3.6致谢 第4章 查找 4.1. 耗时 4.2. 问题:博客数据 4.3. 问题:时间,人物,以及对象? 4.4. 大规模尺度的搜索 4.5. 结论 第5章 正确、优美、迅速(按重要性排序):从设计XML验证器中学到的经验 5.1 XML验证器的作用 5.2 问题所在 5.3 版本1:简单的实现 5.4 版本2:模拟BNF语法——复杂度O(N) 5.5 版本3:第一个复杂度O(log N)的优化 5.6 版本4:第二次优化:避免重复验证 5.7 版本5:第三次优化:复杂度 O(1) 5.8 版本 6:第四次优化:缓存(Caching) 5.9 从故事中学到的 第6章 集成测试框架:脆弱之美 6.1. 三个类搞定一个验收测试框架 6.2. 框架设计的挑战 6.3. 开放式框架 6.4. 一个HTML解析器可以简单到什么程度? 6.5. 结论 第7章 美丽测试 7.1 讨厌的二分查找 7.2 JUnit简介 7.3将二分查找进行到底 7.4 结论 第8章 图像处理中的即时代码生成 第9章 自顶向下的运算符优先级 9.1. JavaScript 9.2. 符号表 9.3. 语素 9.4. 优先级 9.5. 表达式 9.6. 中置运算符 9.7. 前置操作符 9.8. 赋值运算符 9.9. 常数 9.10. Scope 9.11. 语句 9.12. 函数 9.13. 数组和对象字面量 9.14. 要做和要思考的事 第 10章 追求加速的种群计数 10.1. 基本方法 10.2. 分治法 10.3. 其他方法 10.4. 两个字种群计数的和与差 10.5. 两个字的种群计数比较 10.6. 数组中的1位种群计数 10.7. 应用 第11章 安全通信:自由的技术 11.1 项目启动之前 11.2剖析安全通信的复杂性 11.3 可用性是关键要素 11.4 基础 11.5 测试集 11.6 功能原型 11.7 清理,插入,继续…… 11.8 在喜马拉雅山的开发工作 11.9 看不到的改动 11.10 速度确实重要 11.11 人权中的通信隐私 11.12 程序员与文明 第12章 在BioPerl里培育漂亮代码 12.1. BioPerl和Bio::Graphics模块 12.2. Bio::Graphics的设计流程 12.3. 扩展Bio::Graphics 12.4. 结束语和教训 第13章 基因排序器的设计 13.1 基因排序器的用户界面 13.2 通过Web跟用户保持对话 13.3. 多态的威力 13.4 滤除无关的基因 13.5 大规模美丽代码理论 13.6 结论 第14章 优雅代码随硬件发展的演化 14.1. 计算机体系结构对矩阵算法的影响 14.2 一种基于分解的方法 14.3 一个简单版本 14.4 LINPACK库中的DGEFA子程序 14.5 LAPACK DGETRF 14.6递归LU 14.7 ScaLAPACK PDGETRF 14.8 针对多核系统的多线程设计 14.9 误差分析与操作计数浅析 14.10 未来的研究方向 14.11 进一步阅读 第15章 漂亮的设计会给你带来长远的好处 15.1. 对于漂亮代码的个人看法 15.2. 对于CERN库的介绍 15.3. 外在美(Outer Beauty) 15.4. 内在美(Inner Beauty ) 15.5. 结论 第16章,Linux内核驱动模型:协作的好处 16.1 简单的开始 16.2 进一步简化 16.3 扩展到上千台设备 16.4 小对象的松散结合 第17章 额外的间接层 17.1. 从直接代码操作到通过函数指针操作 17.2. 从函数参数到参数指针 17.3. 从文件系统到文件系统层 17.4. 从代码到DSL(Domain-Specific Language) 17.5. 复用与分离 17.6.分层是永恒之道? 第18章 Python的字典类:如何打造全能战士 18.1. 字典类的内部实现 18.2. 特殊调校 18.3. 冲突处理 18.4. 调整大小 18.5. 迭代和动态变化 18.6. 结论 18.7. 致谢 第19章 NumPy中的多维迭代器 19.1 N维数组操作中的关键挑战 19.2 N维数组的内存模型 19.3NumPy迭代器的起源 19.4 迭代器的设计 19.5 迭代器的接口 19.6 迭代器的使用 19.7 结束语 第20章 NASA火星漫步者任务中的高可靠企业系统 20.1 任务与CIP 20.2 任务需求 20.3 系统架构 20.4 案例分析:流服务 20.5 可靠性 20.6 稳定性 20.7 结束语 第21章 ERP5:最大可适性的设计 21.1 ERP的总体目标 21.2 ERP5 21.3 Zope基础平台 21.4 ERP5 Project中的概念 21.5 编码实现ERP5 Project 21.6 结束语 第22章 一匙污水 第23章 MapReduce分布式编程 23.1 激动人心的示例 23.2 MapReduce编程模型 23.3 其他MapReduce示例 23.4 分布式MapReduce的一种实现 23.5 模型扩展 23.6 结论 23.7 进阶阅读 23.8 致谢 23.9 附录:单词计数解决方案 第24章 美丽的并发 24.2 软件事务内存 24.3 圣诞老人问题 24.4 对Haskell的一些思考 24.6 致谢 第25章 句法抽象:syntax-case 展开器 25.1. syntax-case简介 25.2. 展开算法 25.3. 例子 25.4. 结论 第26章 节省劳动的架构:一个面向对象的网络化软件框架 26.1 示例程序:日志服务 26.2 日志服务器框架的面向对象设计 26.3 实现串行化日志服务器 26.4 实现并行日志服务器 26.5 结论 第27章 以REST方式集成业务伙伴 27.1 项目背景 27.2 把服务开放给外部客户 27.3 使用工厂模式转发服务 27.4 用电子商务协议来交换数据 27.5 结束语 第28章 漂亮的调试 28.1 对调试器进行调试 28.2 系统化的过程 28.3 关于查找的问题 28.4 自动找出故障起因 28.5 增量调试 28.6 最小化输入 28.7 查找缺陷 28.8 原型问题 28.9 结束语 28.10 致谢 28.11 进一步阅读 第29章 把代码当作文章 第30章 当你与世界的联系只有一个按钮 30.1 基本的设计模型 30.2 输入界面 30.3 用户界面的效率 30.4 下载 30.5 未来的发展方向 第31章 Emacspeak:全功能音频桌面 31.1 产生语音输出 31.2 支持语音的Emacs 31.3 对于在线信息的简单访问 31.4 小结 31.5 致谢 第32章 变动的代码 32.1 像书本一样 32.2 功能相似的代码在外观上也保持相似 32.3 缩进带来的危险 32.4 浏览代码 32.5 我们使用的工具 32.6 DiffMerge的曲折历史 32.7 结束语 32.8 致谢 32.9 进一步阅读 第33章 为“The Book”编写程序 33.1 没有捷径 33.2 给Lisp初学者的提示 33.3 三点共线 33.4 不可靠的斜率 33.5 三角不等性 33.6 河道弯曲模型 33.7 “Duh!”——我的意思是“Aha!” 33.8 结束语 33.9 进一步阅读 后记
世界顶级程序设计高手的经验总结 【ACM-ICPC全球总冠军】巫泽俊主译 日本ACM-ICPC参赛者人手一册 本书对程序设计竞赛中的基础算法经典问题进行了汇总,分为准备篇、初级篇、中级篇与高级篇4章。作者结合自己丰富的参赛经验,对严格筛选的110 多道各类试题进行了由浅入深、由易及难的细致讲解,并介绍了许多实用技巧。每章后附有习题,供读者练习,巩固所学。 本书适合程序设计人员、程序设计竞赛爱好者以及高校计算机专业师生阅读。 目录 · · · · · · 译者序 前言 第1章 蓄势待发——准备篇 1.1  何谓程序设计竞赛 1.2  最负盛名的程序设计竞赛 1.2.1  世界规模的大赛——Google Code Jam(GCJ) 1.2.2  向高排名看齐!——TopCoder 1.2.3  历史最悠久的竞赛—— ACM-ICPC 1.2.4  面向中学生的信息学奥林匹克竞赛——JOI-IOI 1.2.5  通过网络自动评测——Online Judge(OJ) 1.3  本书的使用方法 1.3.1  本书所涉及的内容 1.3.2  所用的编程语言 1.3.3  题目描述的处理 1.3.4  程序结构 1.3.5  练习题 1.3.6  读透本书后更上一层楼的练习方法 1.4  如何提交解答 1.4.1  POJ的提交方法 1.4.2  GCJ的提交方法 1.5  以高效的算法为目标 1.5.1  什么是复杂度 1.5.2  关于运行时间 1.6  轻松热身 1.6.1  先从简单题开始 1.6.2  POJ的题目Ants 1.6.3  难度增加的抽签问题 阅读 第2章 初出茅庐——初级篇 2.1  最基础的“穷竭搜索” 2.1.1  递归函数 2.1.2  栈 2.1.3  队列 2.1.4  深度优先搜索 2.1.5  宽度优先搜索 2.1.6  特殊状态的枚举 2.1.7  剪枝 2.2  一往直前!贪心法 2.2.1  硬币问题 2.2.2  区间问题 2.2.3  字典序最小问题 2.2.4  其他例题 2.3  记录结果再利用的“动态规划” 2.3.1  记忆化搜索与动态规划 2.3.2  进一步探讨递推关系 2.3.3  有关计数问题的DP 2.4  加工并存储数据数据结构 2.4.1  树和二叉树 2.4.2  优先队列和堆 2.4.3  二叉搜索树 2.4.4  并查集 2.5  它们其实都是“图” 2.5.1  图是什么 2.5.2  图的表示 2.5.3  图的搜索 2.5.4  最短路问题 2.5.5  最小生成树 2.5.6  应用问题 2.6  数学问题的解题窍门 2.6.1  辗转相除法 2.6.2  有关素数的基础算法 2.6.3  模运算 2.6.4  快速幂运算 2.7  一起来挑战GCJ的题目(1) 2.7.1  Minimum Scalar Product 2.7.2  Crazy Rows 2.7.3  Bribe the Prisoners 2.7.4  Millionaire 阅读 第3章 出类拔萃——中级篇 3.1  不光是查找值!“二分搜索” 3.1.1  从有序数组中查找某个值 3.1.2  假定一个解并判断是否可行 3.1.3  最大化最小值 3.1.4  最大化平均值 3.2  常用技巧精选(一) 3.2.1  尺取法 3.2.2  反转(开关问题) 3.2.3  弹性碰撞 3.2.4  折半枚举(双向搜索) 3.2.5  坐标离散化 3.3  活用各种数据结构 3.3.1  线段树 3.3.2  Binary Indexed Tree 3.3.3  分桶法和平方分割 3.4  熟练掌握动态规划 3.4.1  状态压缩DP 3.4.2  矩阵的幂 3.4.3  利用数据结构高效求解 3.5  借助水流解决问题的网络流 3.5.1  最大流 3.5.2  最小割 3.5.3  二分图匹配 3.5.4  一般图匹配 3.5.5  匹配、边覆盖、独立集和顶点覆盖 3.5.6  最小费用流 3.5.7  应用问题 3.6  与平面和空间打交道的计算几何 3.6.1  计算几何基础 3.6.2  极限情况 3.6.3  平面扫描 3.6.4  凸包 3.6.5  数值积分 3.7  一起来挑战GCJ的题目(2) 3.7.1  Numbers 3.7.2  No Cheating 3.7.3  Stock Charts 3.7.4  Watering Plants 3.7.5  Number Sets 3.7.6  Wi-fi Towers 第4章 登峰造极——高级篇 4.1  更加复杂的数学问题 4.1.1  矩阵 4.1.2  模运算的世界 4.1.3  计数 4.1.4  具有对称性的计数 4.2  找出游戏的必胜策略 4.2.1  游戏与必胜策略 4.2.2  Nim 4.2.3  Grundy数 4.3  成为图论大师之路 4.3.1  强连通分量分解 4.3.2  2-SAT 4.3.3  LCA 4.4  常用技巧精选(二) 4.4.1  栈的运用 4.4.2  双端队列的运用 4.4.3  倍增法 4.5  开动脑筋智慧搜索 4.5.1  剪枝 4.5.2  A*与IDA* 4.6  划分、解决、合并:分治法 4.6.1  数列上的分治法 4.6.2  树上的分治法 4.6.3  平面上的分治法 4.7  华丽地处理字符串 4.7.1  字符串上的动态规划算法 4.7.2  字符串匹配 4.7.3  后缀数组 4.8  一起来挑战GCJ的题目(3) 4.8.1  Mine Layer 4.8.2  Year of More Code Jam 4.8.3  Football Team 4.8.4  Endless Knight 4.8.5  The Year of Code Jam 阅读 本书中未涉及的拓展主题 书中例题列表 参考文献
### 回答1: 二分查找是一种在有序数组中查找某个元素的算法。它的基本思想是将数组分成两部分,先判断所要查找的元素是在数组的左半部分还是右半部分,再在相应部分继续进行查找。 具体实现方法如下: 1.首先设置左边界为0,右边界为数组长度-1 2.在整个数组中找到中间元素 3.如果中间元素等于所查找的元素,则返回中间元素的下标 4.如果中间元素大于所查找的元素,则在左半部分继续查找 5.如果中间元素小于所查找的元素,则在右半部分继续查找 6.如果左边界大于右边界,则说明所查找的元素不存在,返回-1 代码示例: ```python def binary_search(arr, x): left = 0 right = len(arr) - 1 while left <= right: mid = (left + right) // 2 if arr[mid] == x: return mid elif arr[mid] < x: left = mid + 1 else: right = mid - 1 return -1 ``` ### 回答2: 二分查找也叫折半查找,是一种高效的查找算法。它针对的是已经有序的数列,在数组的中间找到目标值,缩小查找的范围,不断重复这个过程直到查找到目标值。 下面是利用二分查找找出所给出的数在数组中的下标的具体步骤: 1. 确定要查找的数,以及要查找的数组。 2. 确定数组的起始下标left和结束下标right。 3. 计算数组中间数的下标mid,mid=(left+right)/2。 4. 比较中间数和待查找的数的大小。如果中间数等于待查找的数,则返回mid;如果中间数小于待查找的数,则说明待查找的数在右半部分数组中,将left=mid+1;如果中间数大于待查找的数,则说明待查找的数在左半部分数组中,将right=mid-1。 5. 重复第3、4步,直至找到待查找的数,或者left>right,没有找到待查找的数。 例如,下面是一个有序数组A:[1, 3, 5, 7, 9],我们想要查找数字5在数组中的下标。 1. 确定要查找的数为5,数组A为有序数组。 2. 数组起始下标为0,结束下标为4。 3. 计算中间数的下标为2, mid=(0+4)/2=2。 4. 比较中间数A[mid]=5和待查找的数5,A[mid]==5,返回mid=2。 5. 查找结束。 通过二分查找,我们得到数字5在数组A中的下标是2。 总之,二分查找是一种高效的查找算法,适用于有序的数列。其步骤很简单,但需要注意边界问题。 ### 回答3: 二分查找法也称折半查找法,是一种在有序数组中查找特定元素的算法。它的原理是先找出中间的元素,然后和要查找的元素进行比较,如果中间的元素比要查找的元素小,那么可以排除左半部分,只在右半部分继续查找;如果中间的元素比要查找的元素大,那么可以排除右半部分,只在左半部分继续查找。如此不断地缩小查找范围,直至找到所要查找的元素。 下面是二分查找的具体步骤: 1. 初始化left为数组的第一个元素的下标,right为数组的最后一个元素的下标。 2. 通过(left + right) / 2计算出中间位置mid的下标。 3. 如果要查找的元素等于中间位置上的元素,则直接返回mid的下标。 4. 如果要查找的元素小于中间位置上的元素,则在左半部分继续查找。此时将right赋值为mid - 1。 5. 如果要查找的元素大于中间位置上的元素,则在右半部分继续查找。此时将left赋值为mid + 1。 6. 重复执行步骤2到步骤5,直至找到要查找的元素或者left > right。 如果最后left > right,则说明数组中不存在要查找的元素。 下面是一个示例代码: ``` int binary_search(int arr[], int len, int find){ int left = 0; int right = len - 1; while(left <= right){ int mid = (left + right) / 2; if(arr[mid] == find){ return mid; }else if(arr[mid] > find){ right = mid - 1; }else{ left = mid + 1; } } return -1; } ``` 其中,arr为待查找的数组,len为数组的长度,find为要查找的元素。 调用方式如下: ``` int arr[] = {1, 3, 5, 7, 9}; int len = sizeof(arr) / sizeof(arr[0]); int find = 5; int res = binary_search(arr, len, find); if(res == -1){ printf("未找到该元素!"); }else{ printf("该元素在数组中的下标为:%d", res); } ``` 该程序将会输出:该元素在数组中的下标为:2 因为数组中第三个元素即为5,它的下标为2。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值