Leetcode_二分查找法

最新推荐文章于 2023-01-11 13:41:53 发布
最新推荐文章于 2023-01-11 13:41:53 发布
阅读量219 收藏
点赞数
分类专栏： LeetCode python 文章标签： leetcode 算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43427585/article/details/105457154
版权

二分查找是在“有序数组”中利用“中值”找目标的问题

  • 时间复杂度：O（logN）

两种求中值方法：

  • med = (left + right) // 2
    • med = (left + right) >> 1 替代写法，跟上面是等价的，速度快一些
  • med = left + (right - left) // 2 #应该使用这种，因为第一种存在out of range情况
  • %：表示余数；//表示：地板除（向下取整），在python3中使用。python2没有使用浮点数，则都是地板除

二分查找相对简单，理解while循环和细节就好

  • while left<right,则跳出循环时left=right
  • while left <= right,则跳出循环时 left = right + 1
  • nums[mid]&nums[left]&nums[left]三者的比较就是二分法的核心，针对不同题目变通就好

69. x 的平方根

链接：https://leetcode-cn.com/problems/sqrtx/

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

example:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
     由于返回类型是整数，小数部分将被舍去。

解题思路

对于开方根求法：

  • sqrt = x // sqrt
  • 对比medium与x//medium来判断中值medium在开方根左侧还是右侧。
  • 左侧：更新left至med + 1；右侧：更新right至med - 1
  • 因退出循环时，right = left-1，即right<left。而对于2.83323,我们取2而非3。所以输出right

代码

class Solution:
    def mySqrt(self, x: int) -> int:
        if x < 2:
            return x
        l = 0
        r = x
        while l <= r:
            med = l + ( r - l ) // 2
            sqrt = x // med
            if med < sqrt:
                l = med +1
            elif med > sqrt:
                r = med -1
            else:
                return sqrt
        return r

374. 猜数字大小

链接：https://leetcode-cn.com/problems/guess-number-higher-or-lower

  • 我们正在玩一个猜数字游戏。 游戏规则如下：
  • 我从1到n选择一个数字。 你需要猜我选择了哪个数字。
  • 每次你猜错了，我会告诉你这个数字是大了还是小了。通过调用一个预先定义好的接口 guess(int num)，它会返回 3 个可能的结果（-1，1 或 0）：
    • -1 : 我的数字比较小
    • 1 : 我的数字比较大
    • 0 : 恭喜！你猜对了！

解题思路

二分查找

  • 二分查找标准解法，中间调用一次guess API比大小即可

代码

# The guess API is already defined for you.
# @param num, your guess
# @return -1 if my number is lower, 1 if my number is higher, otherwise return 0
# def guess(num: int) -> int:

class Solution:
    def guessNumber(self, n: int) -> int:
        l,r = 1,n
        while l <= r:
            med = l + ( r - l ) // 2
            dst = guess(med)
            if dst == 1:
                l = med + 1
            elif dst == -1:
                r = med - 1
            else:
                return med

744. 寻找比目标字母大的最小字母

链接：https://leetcode-cn.com/problems/find-smallest-letter-greater-than-target/

给定一个有序的字符数组 letters 和一个字符 target，要求找出 letters 中大于 target 的最小字符，如果找不到就返回第 1 个字符。

解题思路

主干二分查找法，本题有两点需要注意：

  1. 当中值letters[med]=target时，需要输出后一位，等价于letters[med]<target
  2. 输出后一位存在超过边界情况（out of range）,所以需要判断是否大于边界
  3. 因为要找大的,最后退出循环时l是比r大的，所以输出l。

代码

class Solution:
    def nextGreatestLetter(self, letters: List[str], target: str) -> str:
        l = 0
        r = len(letters) -1
        while l <= r:
            med = l + ( r - l ) // 2
            if letters[med] <= target:
                l = med + 1
            elif letters[med] > target:
                r = med - 1
        if l >= len(letters):
            return letters[0]
        return letters[l]

540. 有序数组中的单一元素

给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

链接：https://leetcode-cn.com/problems/single-element-in-a-sorted-array/

examples:

输入: [1,1,2,3,3,4,4,8,8]
输出: 2

解题思路

  1. %：表示余数；//表示：地板除（向下取整），在python3中使用。python2没有使用浮点数，则都是地板除
  2. 规律：只有一个单数，其余都双数，所以总数是基数。
  3. 去除中值与旁边相同的数，目标在剩余数组中基数侧。如果中值本身就是孤立直接输出。
  4. 有个坑：在elif循环里，search_odd算上了当前nums[med，所以这里找的是偶数侧。

代码

class Solution:
    def singleNonDuplicate(self, nums: List[int]) -> int:
        l,h = 0,len(nums)-1
        while l < h:
            med = l + (h - l)//2
            search_odd = (med - l)%2 == 0 
            if nums[med] == nums[med-1]:
                if search_odd:
                    h = med -2
                else:
                    l = med + 1
            elif nums[med] == nums[med+1]:
                if search_odd:
                    l = med + 2
                else:
                    h = med - 1
            else:
                return nums[med]
        return nums[l]

278. 第一个错误的版本

假设你有 n 个版本 [1, 2, …, n]，在第x版本出错导致[x:n]版本都错，找到x。可以调用isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

链接：https://leetcode-cn.com/problems/first-bad-version

example：

给定 n = 5，并且 version = 4 是第一个错误的版本。

调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true

所以，4 是第一个错误的版本。

解题思路

很标准的二分查找法

代码

# The isBadVersion API is already defined for you.
# @param version, an integer
# @return a bool
# def isBadVersion(version):

class Solution(object):
    def firstBadVersion(self, n):
        start = 1
        end = n
        while start <= end:
            mid = start + (end - start) // 2
            if isBadVersion(mid):
                end = mid -1
            else:
                start = mid + 1
        return start

153. 寻找旋转排序数组中的最小值

链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/

升序数组在某点转折，找出数组的最小值

example:

输入: [3,4,5,1,2]
输出: 1

输入: [1,2,3]
输出: 1

解题思路

  1. 二分查找法
  2. 一个小坑是输出[1,2,3]这样的，旋转点就是nums[0],直接return nums[0]
  3. 循环里面：出现nums[i+1]<nums[i]，i+1就是转折点，nums[i+1]也就是最小值。
  4. nums[start]<nums[mid]:意味着[start:mid]中间都是递增的没有转折点，start=mid + 1
  5. nums[start]> nums[mid]:意味着[start:mid]中间有转折点，mid也可能是转折点需要被判断，所以end = mid
  6. 循环结束时，start=end，返回nums[end]即可

代码

class Solution(object):
    def findMin(self, nums):
        start,end = 0,len(nums)-1
        if nums[end]>nums[0]:
            return nums[0]
        while start < end:
            mid = start + ( end - start ) // 2
            if nums[mid] > nums[start]:
                start = mid + 1
            else:
                end = mid
            if nums[mid+1]<nums[mid]:
                return nums[mid+1]
            if nums[mid]<nums[mid-1]:
                return nums[mid]
        return nums[end]

34. 在排序数组中查找元素的第一个和最后一个位置

升序排列的整数数组 nums，和一个目标值 target。找出target在nums中的开始位置和结束位置。如不存在目标值，返回 [-1, -1]。

链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array

example：

解题思路

  1. 二分查找法
  2. start:左边界，end：右边界
  3. 先说特例：nums本身为空，输出[-1,-1]，开头排除掉
  4. 找左边界：
    • 要找左边界，end停靠在左边界位置（nums[end]=target），利用start=mid+1来找
    • 特例：如果nums[0]=target,左边界就是0，先排除掉
    • while start<end:则跳出循环时start = end，且nums[start]=nums[end]=target,输出哪个都可以
  5. 找右边界：
    • 要找右边界，end必须停靠在右边界+1位置上（nums[end]!=target），利用start=mid+1来找
      • 这里不用start=mid因为mid是向下取整，会无法跳出循环；
      • 如[2,3],target=2时,当start和end的位置在1时才能跳出循环，但start永远在index=0处循环
    • 特例：如果nums[len(nums)-1]=target,右边界就是len(nums)-1，先排除掉
    • while start<end:则跳出循环时，start = end,且nums[start-1]=nums[end-1]=target

代码

class Solution(object):
    def searchRange(self, nums, target):
        if not nums:
            return[-1,-1]
        #find left_index
        start,end = 0,len(nums)-1
        if nums[start] == target:
            left_index = 0
        else:
            while start < end:
                mid = start + ( end -start ) // 2
                if nums[mid] >= target:
                    end = mid
                else:
                    start = mid + 1        
            left_index = start

        #find right_index
        start,end = 0,len(nums)-1
        if nums[end] == target:
            right_index = len(nums) - 1
        else:
            while start < end:
                mid = start + (end - start) // 2
                if nums[mid] > target:
                    end = mid
                else:
                    start = mid + 1
            right_index = start -1

        if left_index == len(nums) or nums[left_index] != target:
            return [-1,-1]
        return [left_index,right_index]
刘cx的玉米地
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode - 二分查找
qq_44822951的博客
11-27 249
无
数据结构算法——二分查找问题（以LeetCode二分查找题为例）
枫陵的博客
05-29 2114
一. 二分查找的定义 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法，前提是数据结构必须先排好序。 二分查找采用的是一种分治策略，它充分利用了元素间的次序关系，可在最坏的情况下用O(log n)完成搜索任务。 基本思想：假设数组元素呈升序排列，将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止；如 果x<a[n/2]，则我们只要在a的左半部分继续搜索x；如果x&...
leetcode——二分查找
weixin_43952736的博客
02-24 338
1.69 public static int mySqrt(int x) { int l = 0, r = x, ans = -1; while (l <= r) { int mid = l + (r - l) / 2; if ((long) mid * mid <= x) { ans = mid; l = mid + 1; } else {
leetcode-二分查找
attack_city_lion的博客
06-21 160
目录 leetcode-二分查找 原理 代码实现 代码模板 典型例题分解 410 33 1552 540 总结 leetcode-二分查找 原理 二分查找也叫折半查找。 基本思想： 1 在有序表中，取中间记录作为比较对象 1.1 若给定与中间记录的关键字相等，则查找成功； 1.2 若给定值小于中间记录的关键字，则在中间记录的左半区继续查找； 1.3 若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。 2 不断重复1过程，直到查找成功，或在查找区域无记录，查找失
LeetCode-二分查找
wangdsdasdasdas的博客
08-25 190
LeetCode二分查找相关题目
leetcode分类-Leetcode_python:leetcode问题
06-29
leetcode 分类 Leetcode_python 带星号(加粗)的题目是需要重点掌握的经典题/特殊技巧题 程序员面试金典 剑指Offer LeetCode 数组 字符串 哈希表 ...二分查找 动态规划/贪心算法 回溯法/递归 DFS/BFS
leetcode怎么销号-LeetCode_Practice:力扣_实践
06-30
leetcode怎么销号 LeetCode_Practice python C++ 本人是研二菜鸟一枚，这是我的练习记录，记录了我的解题代码和解题思路总结，将不断更新。...给出一个升序数组，通过二分查找算法，确定target的位置，比较
leetcode_CPP：c ++版本leetcode
02-14
二分查找 53 简单 动态规划 66 简单 88 简单 118 简单 119 简单 动态规划 121 简单 122 简单 贪心 167 简单 双指针 169 简单 哈希，众数，Boyer-Moore 217 简单 设置，排序，哈希 219 简单 哈希，滑动...
LeetCode算法蛇形走位-leetcode_way:leetcode解决方案的降价
06-30
二分查找 scan DP,fibonacci recursion DP 中序遍历 recursion 递归 recursion DP recursion or math math math DP DP 递归？回溯+减支？ dfs recursion map (归并排序) math 遍历 split math 《$Algorithm$》 heap ...
leetcode2-leetcode_notes:这个是我在刷leetcode的时候的一些笔记
06-29
leetcode 2 leetcode_notes 这个是我在刷leetcode的时候的一些笔记 灵感来自： 顺序刷： 分类刷： Pythonic： 这里主要按照两个方向刷题： 1.顺序刷 Top ...O((m+n)log(m+n))2.二分查找法 O(log(m+n
第一个错误的版本 -- java记录
zkhong07的博客
09-27 298
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。 假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。 你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现...
leetcode基础题：二分查找
Esteban123的博客
01-11 198
力扣二分查找的一些简单题，所有代码均为通过
数据结构：二分查找模版与例题
黑哥的博客
10-12 2142
欢迎关注我的简书：https://www.jianshu.com/u/55a1bc4688c6 本文源自LeetCode二分查找章节，通过本章节的练习对二分查找的基础知识进行掌握，同时能够利用二分查找解决部分问题。二分查找是一个效率非常高的算法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。掌握二分查找对于提升代码效率很有帮助。 LeetCode二分查...
深入理解二分查找：从LeetCode实践出发【1】（题号34、35）
白马负金羁
10-19 3610
二分查找是数据结构与算法课程中应该讲到的一个非常重要的内容。通常，二分查找算法可以通过迭代来实现，也可以借由递归的结构来实现。但是在实际应用中二分查找可能变化出许多更为复杂的形式
kuangbin 专题二十三：二分 尺取 单调栈队列 Pie
weixin_45867800的博客
11-01 315
题目链接： 传送门 #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #include<cmath> using namespace std; const int N = 10010; //这里一定要注意精度，一开始我写了1e-6结果wa了 const double DIF = 1e-8; const double PI = acos(-1.0);
旋转数组的最小数字
weixin_34342578的博客
11-03 212
    题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3，4，5，1，2}为{1，2，3，4，5}的一个旋转，该数组的最小值为1. 实现数组的旋转见左旋转字符串。 和二分查找法一样，用两个指针分别指向数组的第一个元素和最后一个元素。 我们注意到旋转之后的数组实际上可以划分...
二分查找与二分答案——【深基13.例1】查找
linjiayina的博客
08-07 1775
二分查找与二分答案——【深基13.例1】查找 题目描述 输入 n(n ≤ 106) 个不超过 109 的单调不减的（就是后面的数字不小于前面的数字）非负整数 a1,a2,…,an，然后进行 m(m ≤ 105) 次询问。对于每次询问，给出一个整数 q(q ≤ 109)，要求输出这个数字在序列中的编号，如果没有找到的话输出 -1。 输入格式 第一行 2 个整数 n 和 m，表示数字个数和询问次数。 第二行 n 个整数，表示这些待查询的数字。 第三行 m 个整数，表示询问这些数字的编号，从 1 开始编号。 输出
二分查找，来一道不是那么复杂的题目
热门推荐
August-us的博客
05-12 2万+
二分查找，来一道不是那么复杂的题目题目描述题目分析C++代码相关文章：[二分查找的特性及应用](https://blog.csdn.net/m0_38065572/article/details/104522499)   二分查找的思想和套路已经了然于心了，但是还是有些问题解决不了？这个时候就可能需要多见一些特殊的用例了。这一次再来一种二分查找的特例。 题目描述 峰值元素是指其值大于左右相邻值的元素。 给定一个输入数组 nums，其中 nums[i] ≠ nums[i+1]，找到峰值元素并返回其索引。
leetcode刷题顺序
最新发布
07-27
根据引用\[1\]和引用\[2\]的内容，推荐的LeetCode刷题顺序是按照题目类型刷题，优先选择树、链表、二分查找、DFS、BFS、动态规划等常见类型的题目。可以先做2~4道简单题，然后再做中等难度的题目。在选择题目时，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值