LintCode-62: Search in Rotated Sorted Array (经典Binary Search题)

33. 搜索旋转排序数组(Search in Rotated Sorted Array) 题目描述 假设按照升序排序的数组在预先未知的某个点上进行了旋转。 ( 例如,数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 搜索一个给定的目标值,如果数组中存在这个目标值,则返回它的索引,否则返回 -1 。 你可以假设数组中不存在重复的元素。 你的算法时间复杂度必须是 O(log n) 级别。 分析 数组旋转 本题是数组,而且要求时间复杂度为 O(log n) 。应该能够自然想到二分查找。 但是直接使用二分查找行不行呢?我们看一看下面这个例子: 在数组[3 4 5 阅读详情

这题应该是Binary Search题里面最经典的一道了。
注意它跟Rotated Sorted Array里面找minimum要复杂一些。找minimum的题没有target,只需要把A[mid]跟A[start]比较就可以知道是在第二象限还是第四象限,从而把数据分为OOOOXXXX两部分继续二分。

而这道题目需要把A[mid]和target两个值都跟A[start]比较。所以有很多种情况。
case 1: A[mid]==target 直接返回mid即可。
case 2: A[mid]>A[start] && target<A[start] 这种情况说明mid在第一象限,target在第四象限,扔左半边即可。
case 3: A[mid]<A[start] && target>A[start] 这种情况说明mid在第四象限,target在第二象限,扔右半边即可。
case 4: A[mid]<A[start] && target<A[start] 这种情况说明mid在第四象限,target也在第四象限。这个就回到经典的Binary Search了。我们再比较A[mid]和target。如果A[mid]>target,扔右半边,否则扔左半边。
case 5: A[mid]>A[start] && target>A[start] 这种情况说明mid在第一象限,target也在第一象限。比较A[mid]和target。如果A[mid]>target,扔右半边,否则扔左半边。所以case 4和case 5可以合并。

代码如下:

    int search(vector<int> &A, int target) {
        if (A.size()==0) return -1;
        int start=0, end=A.size()-1;
        
        if (A[start]==target) return start;
        if (A[end]==target) return end;
        
        while(start+1<end) {
            int mid=start+(end-start)/2;
            if (A[mid]==target) return mid;
            if (A[mid]>A[start] && target<A[start]) start=mid;
            if (A[mid]<A[start] && target>A[start]) end=mid;
            
            if ((A[mid]<A[start] && target<A[start]) || (A[mid]>A[start] && target>A[start])) {
                if (A[mid]>target) end=mid;
                else start=mid;
            }

        }
        if (A[start]==target) return start;
        if (A[end]==target) return end;
        return -1;
    }

注意:
1)应该把A[mid]和target都跟A[start]比。把A[mid]跟A[start]比,然后A[mid]跟target比是不对的。比如说A[mid]>A[start] (第二象限),A[mid]>target,但我们并不知道target是落在第二象限还是第四象限!
2) 我们一开头需要比较A[start]和A[end]是不是已经等于target。否则A[]={1,2,3},start=0, end=2, mid=1, 然后几个if又都不满足,陷入死循环。

二刷:

class Solution {
public:
    /**
     * @param A: an integer rotated sorted array
     * @param target: an integer to be searched
     * @return: an integer
     */
    int search(vector<int> &A, int target) {
        int n = A.size();
        if (n == 0) return -1;
        
        int start = 0, end = n - 1;
        
        if (A[start] == target) return start;
        if (A[end] == target) return end;
        
        while(start + 1 < end) {
            int mid = start + (end - start) / 2;

            if (A[mid] == target) return mid;

            if (A[mid] > A[start]) {
                if (target < A[mid] && target > A[start]) end = mid;
                else start = mid;
            }
            
            if (A[mid] < A[start]) {
                if (target > A[mid] && target < A[end]) start = mid;
                else end = mid;
            }
            
        }

        if (A[start] == target) return start;
        if (A[end] == target) return end;
        
        return -1;
    }
};

三刷

class Solution {
public:
    /**
     * @param A: an integer rotated sorted array
     * @param target: an integer to be searched
     * @return: an integer
     */
    int search(vector<int> &A, int target) {
        int n = A.size();
        if (n == 0) return -1;
        int start = 0, end = n - 1;
        while (start + 1 < end) {
            int mid =  start + (end - start) / 2;

            if (A[mid] < A[start] && target > A[start]) {
                end = mid;
            } else if (A[mid] > A[start] && target < A[start]) {
                start = mid;
            } else if ((A[mid] > A[start] && target >= A[start]) ||
                       (A[mid] < A[start] && target < A[start])) {
                if (A[mid] > target) {
                    end = mid;
                } else if (A[mid] < target) {
                    start = mid;
                } else {
                    return mid;
                }
            } 
        }
        if (A[end] == target) return end;
        if (A[start] == target) return start;
        return -1;
    }
};

上面可以简化为:

class Solution {
public:
    /**
     * @param A: an integer rotated sorted array
     * @param target: an integer to be searched
     * @return: an integer
     */
    int search(vector<int> &A, int target) {
        int n = A.size();
        if (n == 0) return -1;
        int start = 0, end = n - 1;
        while (start + 1 < end) {
            int mid =  start + (end - start) / 2;
            if (A[mid] < A[start] && target > A[start]) {
                end = mid;
            } else if (A[mid] > A[start] && target < A[start]) {
                start = mid;
            } else {
                if (A[mid] > target) {
                    end = mid;
                } else if (A[mid] < target) {
                    start = mid;
                } else {
                    return mid;
                }
            } 
        }
        if (A[end] == target) return end;
        if (A[start] == target) return start;
        return -1;
    }
};

四刷: <= end就表示在右分支,> end表示在左分支。

class Solution {
public:
    /**
     * @param a: an integer rotated sorted array
     * @param target: an integer to be searched
     * @return: an integer
     */
    int search(vector<int> &a, int target) {
        int aSize = a.size();
        if (aSize == 0) return -1;
        int start = 0, end = aSize -1;

        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if ((target <= a[end] && a[mid] <= a[end]) ||
                (target > a[end] && a[mid] > a[end])) {
                if (target < a[mid]) {
                    end = mid;
                } else {
                    start = mid;
                }
            } else if (target <= a[end] && a[mid] > a[end]) {
               start = mid;
            } else {
                end = mid;
            }
        }
        
        if (a[start] == target) return start;
        if (a[end] == target) return end;
        return -1;
    }
};

五刷:

class Solution {
public:
    /**
     * @param a: an integer rotated sorted array
     * @param target: an integer to be searched
     * @return: an integer
     */
    int search(vector<int> &a, int target) {
        int len = a.size();
        if (len == 0) return -1;
        int start = 0, end = len - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (a[mid] <= a[end])
            {
                if (target >= a[mid] && target <= a[end]) {
                    start = mid;
                } else {
                    end = mid;
                }
            } else {
               if (target <= a[mid] && target > a[end]) {
                   end = mid;
               } else {
                   start = mid;
               }
            }
        }
        if (a[end] == target) return end;
        if (a[start] == target) return start;
        return -1;
    }
};

六刷

class Solution {
public:
    /**
     * @param a: an integer rotated sorted array
     * @param target: an integer to be searched
     * @return: an integer
     */
    int search(vector<int> &a, int target) {
       int n = a.size();
       if (n == 0) return -1;
       int start = 0, end = n - 1;
       while (start + 1 < end) {
           int mid = start + (end - start) / 2;
          // if (a[mid] == target) return mid;
           if (a[mid] > a[start]) { //mid is in the left part
               if (a[start] <= target && target <= a[mid]) { //target is b/w start and mid
                   end = mid;
               } else { //target is b/w mid and end
                   start = mid;
               }
           } else { //mid is in the right part
              if (a[mid] <= target && target <= a[end]) { //target is b/w mid and end
                  start = mid;
              } else {
                  end = mid;
              }
           }
       }
       if (a[start] == target) return start;
       if (a[end] == target) return end;
       return -1;
    }
};
【Docker】如何让docker容器正常使用nvidia显卡 描述了如何在docker容器中使用英伟达显卡的过程和问题解决方法。 阅读详情

相关推荐

视觉语言模型在三维导航中的应用:JanusVLN项目解析与实战

视觉语言模型(VLM)作为多模态人工智能的核心技术,通过融合视觉感知与自然语言理解能力,实现了对开放世界场景的语义化解析。其原理在于利用预训练的视觉编码器和大型语言模型,将图像信息映射到与文本对齐的语义空间,从而完成跨模态的推理与生成。这一技术为机器人自主交互、智能家居控制等场景提供了基础能力支撑,尤其在需要理解复杂指令并执行序列决策的任务中展现出巨大价值。本文聚焦于视觉语言导航(VLN)这一具体应用,探讨如何通过架构创新与高效微调策略,将通用VLM适配到三维仿真环境中的导航任务,并以JanusVLN项目为

weixin_30240349的博客 671

Search in Rotated Sorted Array

Search in Rotated Sorted Array 对一个有序排列的数组,升序排列,每个数各不相同。将其中前面一部分数据挪到后面变成一个新的数组,给定一个数,求这个数在新数组中的下标。 该数存在则返回下标,否则返回-1。 思路: 首先使用二分查找找到数组中最小的那个数的位置small_index,然后以最小的这个数为轴,可以将该数组划分为两部分,small_index之前的数为升...

HuZhenXing 346

【银行测试】手机银行APP专项项目+测试点汇总(一)

1、手机银行APP转账项目讲解面试官:请介绍一下你所负责的模块如何进行的测试?求职者:好的,我最近测试的是XX银行的手机银行App项目。这个项目里面包含了转账、转账额度调整、网银转账、交易明细、添加账户、存款、投资理财、生活缴费等功能模块。我主要负责了转账模块,这个大模块中包含了智能转账、手机转账、语音转账、预约转账、收款人管理等5个子模块,我首先介绍一下我们生活中使用最多的手机转账子模块。对于转账需要关注的是转账前、转账中、转账后这三个状态下的测试。

m0_70102063的博客 1608

【Leetcode】33. Search in Rotated Sorted Array

题目地址: https://leetcode.com/problems/search-in-rotated-sorted-array/ 在旋转数组里找数。用二分法。每次求出中点mid时,判断一下mid在左半上升区间还是右半上升区间,然后分情况讨论。只有分出单调区间才能用二分法去判断。代码如下: public class Solution { public int search(int[] ...

数学、算法爱好者的博客 277

1、STVD和STVP的使用及串口烧写程序教程

文章目录一、前述二、STVD的使用三、STVP的使用1、STVP的作用:2、STVP的使用四、串口烧录程序 一、前述 STVD是意法半导体推出的,可以支持STM8和STM32 而IAR不尽如此,还支持51,MSP430等芯片 软件开发环境:编写程序,调试软件功能,下载固件到单片机中 硬件开发环境:连接外围电路,驱动功能外设,实现电气功能 最终构成一个以STM8系列单片机作为控制核心的应用系统。 MCS-51 一般的开发环境是 IAR 和 Keil STM8 一般的开发环境是 IAR 和 ST

Clichong 1万+

pyecharts可视化图表-tree:从入门到精通

本文系统介绍了树图(Tree Chart)的可视化技巧,包含基础实现、方向定制和环形布局等实例。树图能清晰展示层次结构数据,适用于组织架构、文件系统等场景。教程详细解析了pyecharts树图的核心配置项,包括数据准备、方向设置(下上、右左)和样式定制,并提供了完整代码示例。通过本指南,读者可快速掌握专业树图的构建方法,实现复杂层次数据的可视化呈现。

大数据内容个人总结与分享 1971

Search in Rotated Sorted Array - 循环有序数组查找问题

两道题 33.Search in Rotated Sorted Array Loading... 81.Search in Rotated Sorted Array II Loading... 这两道题都是属于循环有序数组的查找问题,无论是查找具体元素的下标还是检查一个目标值是否在数组中,主要的判断逻辑都是一致的。 思路 这种将有序数组翻转成循环有序数组的解决办法是将原数组分段。用首元素start、中间元素mid、尾元素end,可以将数组分为两个子数组s1,s2。 则这两个子数组中,必...

翎野君的博客 635

工业质检实战:用海康VisionMaster的BLOB分析搞定PCB焊点缺陷检测

本文详细介绍了如何利用海康VisionMaster平台的BLOB分析技术,构建一套针对PCB焊点缺陷的自动化视觉检测方案。文章从核心原理出发,重点阐述了如何通过动态阈值分割和模板匹配定位,克服工业现场光照不均、位置偏移等挑战,实现虚焊、漏焊等缺陷的精准、稳定检测,并提供了实战调优与系统集成的关键思路。

weixin_29091105的博客 569

搜索旋转排序数组(search-in-rotated-sorted-array)

搜索旋转排序数组(search-in-rotated-sorted-array) 假设按照升序排序的数组在预先未知的某个点上进行了旋转。 ( 例如,数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 搜索一个给定的目标值,如果数组中存在这个目标值,则返回它的索引,否则返回 -1 。 你可以假设数组中不存在重复的元素。 你的算法时间复杂度必须是 O(log n) 级...

mirana的专栏 452

计算机组成原理(第三版)唐朔飞-第六章计算机的运算方法-课后习题(17-32)

计算机组成原理(第三版)唐朔飞-第六章计算机的运算方法-课后习题(17-32)

weixin_45735391的博客 12万+

第八届传智杯WPS智能办公能力挑战赛练习题库

本文是关于WPS Office软件操作知识的选择题汇总,内容涵盖WPS文字、表格和演示三大组件的常用功能。主要包括:云文档协同编辑、文本框插入、幻灯片打印设置、数据排序与筛选、函数应用(如SUMIF、COUNT)、动画效果设置、格式刷使用、页眉页脚设置、单元格引用类型等基础操作要点。同时涉及计算机基础概念如二进制、ROM存储器等。题目以单选和多选形式呈现,附带详细答案解析,全面检验用户对WPS办公软件的功能掌握程度和实际操作能力,适用于办公软件技能培训和水平测试。

qq_73044452的博客 1439

算法:搜索数字,从有逆序的顺序数组33. Search in Rotated Sorted Array

说明 算法:Search in Rotated Sorted Array 地址:https://leetcode.com/problems/search-in-rotated-sorted-array/ Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand. (i....

AI架构师易筋 465

JavaFX Stage

JavaFXStagejavafx.stage.Stage表示 JavaFX 桌面应用程序中的窗口。在 JavaFX 内部,Stage您可以插入一个 JavaFX Scene,它表示在窗口内显示的内容 - 在Stage.当 JavaFX 应用程序启动时,它会创建一个根Stage对象,该对象将传递给 start(Stage primaryStage)JavaFX 应用程序的根类的方法。此Stage 对象代表 JavaFX 应用程序的主窗口。

2012年开始工作,全栈开发老兵,目前已是一个老师,分享这么多年的心得体会 509

二分搜索终极指南:如何一举攻克LintCode 15道经典题目

**二分搜索**(Binary Search)是算法面试中出现频率最高的技巧,也是新手最容易写出死循环的算法。本文基于开源项目 **LintCode**(C++11 解答全部 289 道 LintCode 题目的经典仓库),精选其中 **15 道经典二分搜索题目**,按「基础查找 → 旋转数组 → 二分答案」三个阶段逐步拆解,帮你在一个晚上建立完整的二分思维框架 🎯 ## 为什么值得专门攻克二

gitblog_00993的博客 853

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

leetcode 33. Search in Rotated Sorted Array(旋转排序数组搜索)

binary search

蓝羽飞鸟的博客 227

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Search in Rotated Sorted Array(搜索排序数组)

Search in Rotated Sorted Array(搜索排序数组) 描述: Supposeasortedarrayisrotatedatsomepivotunknowntoyoubeforehand. 2.1 数组 5 (i.e.,0 1 2 4 5 6 7mightbecome4 5 6 7 0 1 2). Youaregivenatargetvaluetosearch. Iffoun...

amor_1的博客 186

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

LeetCode解题报告—— Search in Rotated Sorted Array & Search for a Range & Valid Sudoku

1.Search in Rotated Sorted Array Suppose an array sorted in ascending order is rotated(轮流,循环) at some pivot(枢轴; 中心点) unknown to you beforehand(提前; 事先). (i.e.,0 1 2 4 5 6 7might become4 5 6 ...

dbvz4901的博客 146

Search in Rotated Sorted Array 搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例如,数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。搜索一个给定的目标值,如果数组中存在这个目标值,则返回它的索引,否则返回 -1 。你可以假设数组中不存在重复的元素。你的算法时间复杂度必须是 O(log n) 级别。示例 1:输入: nums = [4,5,6,7,0,1,2], target = 0...

qq_26410101的博客 3970

LeetCode 33-Search in Rotated Sorted Array(二分,旋转有序数组)

LeetCode 33-Search in Rotated Sorted Array题解

祝如愿的博客 112

【LeetCode】 Search in Rotated Sorted Array 系列

Search in Rotated Sorted Array 系列 33. Search in Rotated Sorted Array 81. Search in Rotated Sorted Array II

夏至亦韵 261

[LeetCode 题解] Search in Rotated Sorted Array

前言 【LeetCode 题解】系列传送门: http://www.cnblogs.com/double-win/category/573499.html 题目描述 Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand. (i.e., 0 1 2 4 5 6 7 m...

weixin_30425949的博客 115

Leetcode 33搜索旋转排序数组 Search in Rotated Sorted Array

整数数组nums按升序排列,数组中的值。在传递给函数之前,nums在预先未知的某个下标k)上进行了,使数组变为(下标 从计数)。例如,在下标3处经旋转后可能变为。给你的数组nums和一个整数target,如果nums中存在这个目标值target,则返回它的下标,否则返回-1。你必须设计一个时间复杂度为O(log n)的算法解决此问题。

imlxinyu的博客 228

33.Search in Rotated Sorted Array windliang

题目描述(中等难度) 开始的时候想复杂了,其实就是一个排序好的数组,把前边的若干的个数,一起移动到末尾就行了。然后在 log (n) 下找到给定数字的下标。 总的来说,log(n),我们肯定得用二分的方法了。 首先我们想一下变化前,正常的升序。我们怎么找给定的数字。 我们每次只关心中间位置的值(这一点很重要),也就是上图 3 位置的数值,如果 target 小于 3 位置的值,我们就把 3 4...

猫敷雪 318

LeetCode 33. Search in Rotated Sorted Array - 二分查找(Binary Search)系列题2

​这题是经典二分查找算法也就是LeetCode 704. Binary Search的变形,它把一个排好序的数组做了旋转从而破坏了数组的单调递增性,从而使得判断目标数是落在哪个区间的难度加大。 由于题目中是把一个排好序的数组做了旋转,也就是说旋转后的数组只有一个地方的递增性被破坏,要么是前半区间要么就是后半区间。而对于仍然是单调递增的那一半区间,我们很容易判断目标数是否在该区间,如不在那就肯定在另一半区间。​

hgq522的博客 784

Leetcode33. Search in Rotated Sorted Array | Binary Search

关键在于原本的数列是一个递增数列,所以[k,n-1]里所有的元素都大于[0,k-1]。但其实上面的很多条件都是可以简化的,比如[left,right]作为起始区间,其实没必要再判断nums[right]nums[left]是否符合target_value的大小条件了,加上二者是互斥的,target_value不在第一个区间它就一定在第二个区间,所以直接用else就可以。它的原理是很好理解的,如果当前的区间是左端点大于右端点的,那它一定是两个数列都横跨了,我们要找的界限一定在这里。......

CarpeDiem 321
上一篇: LintCode 74: First Bad Version
下一篇: LintCode-539: Moving Zeros
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值