【面试】每日力扣题 Day5——二分法 1

于 2024-09-16 22:08:24 发布
阅读量556 收藏 7
点赞数 10
文章标签： 面试 leetcode 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45584892/article/details/142306128
版权

二分法基本步骤

  1. 初始化边界：
    • 定义左边界 left 和右边界 right，通常初始化为数组的起始索引和结束索引。
  2. 计算中间位置：
    • 计算中间位置 mid，通常使用公式 left + (right - left) // 2。
  3. 比较中间元素：
    • 将中间位置的元素 arr[mid] 与目标元素 target 进行比较。
    • 如果 arr[mid] == target，则找到目标元素，返回 mid。
    • 如果 arr[mid] < target，则目标元素在右半部分，更新左边界 left = mid + 1。
    • 如果 arr[mid] > target，则目标元素在左半部分，更新右边界 right = mid - 1。
  4. 重复步骤 2 和 3：
    • 不断缩小查找范围，直到左边界超过右边界，表示目标元素不存在于数组中。

35、搜索插入位置

链接：35、搜索插入位置

题目描述：
在这里插入图片描述

方法 1

# 方法 1：二分法(闭区间)
class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
	    # 初始化左边界和右边界
	    left, right = 0, len(nums) - 1
	    
	    # 开始二分查找
	    while left <= right:
	        # 计算中间位置，避免直接使用 (left + right) // 2 可能导致的整数溢出
	        mid = left + (right - left) // 2
	        
	        # 如果中间元素等于目标值，返回中间位置
	        if nums[mid] == target:
	            return mid
	        # 如果中间元素小于目标值，目标值在右半部分，更新左边界
	        elif nums[mid] < target:
	            left = mid + 1
	        # 如果中间元素大于目标值，目标值在左半部分，更新右边界
	        else:
	            right = mid - 1
	    
	    # 如果目标值不存在于数组中，返回插入位置
	    return left

代码解释

  1. 初始化边界：
    • left 初始化为 0，表示数组的起始索引。
    • right 初始化为 len(nums) - 1，表示数组的结束索引。
  2. 循环查找：
    • 使用 while left <= right 循环，确保查找范围有效。
    • 计算中间位置 mid，使用公式 mid = left + (right - left) // 2，避免直接使用 (left + right) // 2 可能导致的整数溢出。
  3. 比较中间元素：
    • 如果 nums[mid] == target，则找到目标元素，返回 mid。
    • 如果 nums[mid] < target，则目标元素在右半部分，更新左边界 left = mid + 1。
    • 如果 nums[mid] > target，则目标元素在左半部分，更新右边界 right = mid - 1。
  4. 返回插入位置：
    • 如果循环结束后仍未找到目标元素，返回 left，表示目标值的插入位置。

复杂度分析

  • 时间复杂度：O(log n)，其中 n 是数组的长度。每次查找范围减半，因此时间复杂度为对数级别。
  • 空间复杂度：O(1)，只使用了常数级别的额外空间。

方法 2

lower_bound 函数：返回最小的满足 nums[i] >= target 的 i

# 方法 2：lower_bound 
class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
    	return lower_bound(nums, target)

复杂度分析

  • 时间复杂度：O(log n)，其中 n 是数组的长度。每次查找范围减半，因此时间复杂度为对数级别。
  • 空间复杂度：O(1)，只使用了常数级别的额外空间。

方法 3

bisect_left 函数：用于在有序列表中查找插入位置。它返回一个位置，使得插入元素后列表仍然保持有序。如果元素已经存在于列表中，返回它的左侧位置。

# 方法 3：bisect_left 
class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
    	return lower_bound(nums, target)

复杂度分析

  • 时间复杂度：O(log n)
  • 空间复杂度：O(1)

74、搜索二维矩阵

链接：74、搜索二维矩阵

题目描述：
在这里插入图片描述

方法 1

思路：

由于矩阵的每一行是递增的，且每行的第一个数大于前一行的最后一个数，如果把矩阵每一行拼在一起，我们可以得到一个递增数组。

例如示例 1，三行拼在一起得 a=[1,3,5,7,10,11,16,20,23,30,34,60]。由于这是一个有序数组，我们可以用二分查找判断 target 是否在 matrix中。

转化方式： a[i]=matrix[⌊i/n⌋][i%n]

# 方法 1：二分法
class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        # 检查矩阵是否为空或矩阵的第一行是否为空
        if not matrix or not matrix[0]:
            return False
        
        # 获取矩阵的行数和列数
        m, n = len(matrix), len(matrix[0])
        # 初始化左边界和右边界
        left, right = 0, m * n - 1
        
        # 开始二分查找
        while left <= right:
            # 计算中间位置，避免直接使用 (left + right) // 2 可能导致的整数溢出
            mid = left + (right - left) // 2
            # 将中间位置映射回二维矩阵中的行和列
            mid_value = matrix[mid // n][mid % n]
            
            # 如果中间元素等于目标值，返回 True
            if mid_value == target:
                return True
            # 如果中间元素小于目标值，目标值在右半部分，更新左边界
            elif mid_value < target:
                left = mid + 1
            # 如果中间元素大于目标值，目标值在左半部分，更新右边界
            else:
                right = mid - 1
        
        # 如果循环结束后仍未找到目标值，返回 False
        return False

代码解释

  1. 检查矩阵是否为空：
    • 如果矩阵为空或矩阵的第一行为空，返回 False。
  2. 初始化边界：
    • m 是矩阵的行数，n 是矩阵的列数。
    • left 初始化为 0，表示一维数组的起始索引。
    • right 初始化为 m * n - 1，表示一维数组的结束索引。
  3. 循环查找：
    • 使用 while left <= right 循环，确保查找范围有效。
    • 计算中间位置 mid，并将其映射回二维矩阵中的行和列。
    • 比较中间元素 mid_value 与目标值 target。
    • 如果 mid_value == target，返回 True。
    • 如果 mid_value < target，目标值在右半部分，更新左边界 left = mid + 1。
    • 如果 mid_value > target，目标值在左半部分，更新右边界 right = mid - 1。
  4. 返回结果：
    • 如果循环结束后仍未找到目标值，返回 False。

复杂度分析

  • 时间复杂度：O(log(m * n))，其中 m 是矩阵的行数，n 是矩阵的列数。每次查找范围减半，因此时间复杂度为对数级别。
  • 空间复杂度：O(1)，只使用了常数级别的额外空间。

方法 2

思路：这种方法利用了矩阵的有序性，从右上角开始搜索。如果当前元素大于目标值，则向左移动；如果当前元素小于目标值，则向下移动。这样可以确保每一步都缩小搜索范围。

# 方法 2：从右上角开始的搜索
class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        # 检查矩阵是否为空或矩阵的第一行是否为空
        if not matrix or not matrix[0]:
            return False
        
        # 获取矩阵的行数和列数
        m, n = len(matrix), len(matrix[0])
        # 从右上角开始搜索
        row, col = 0, n - 1
        
        # 当行索引在矩阵范围内且列索引在矩阵范围内时继续搜索
        while row < m and col >= 0:
            # 如果当前元素等于目标值，返回 True
            if matrix[row][col] == target:
                return True
            # 如果当前元素大于目标值，向左移动一列
            elif matrix[row][col] > target:
                col -= 1
            # 如果当前元素小于目标值，向下移动一行
            else:
                row += 1
        
        # 如果循环结束后仍未找到目标值，返回 False
        return False

代码解释

  1. 检查矩阵是否为空：
    • 如果矩阵为空或矩阵的第一行为空，返回 False。
  2. 获取矩阵的行数和列数：
    • m 是矩阵的行数，n 是矩阵的列数。
  3. 初始化搜索起点：
    • 从右上角开始搜索，初始化 row 为 0，col 为 n - 1。
  4. 循环查找：
    • 使用 while row < m and col >= 0 循环，确保行索引和列索引在矩阵范围内。
    • 如果当前元素 matrix[row][col] 等于目标值，返回 True。
    • 如果当前元素 matrix[row][col] 大于目标值，向左移动一列，即 col -= 1。
    • 如果当前元素 matrix[row][col] 小于目标值，向下移动一行，即 row += 1。
  5. 返回结果：
    • 如果循环结束后仍未找到目标值，返回 False。

复杂度分析

  • 时间复杂度：O(m + n)，其中 m 是矩阵的行数，n 是矩阵的列数。每一步要么向左移动一列，要么向下移动一行。
  • 空间复杂度：O(1)，只使用了常数级别的额外空间。

方法 3

思路：对每一行进行二分查找，查找目标值是否在当前行中。虽然时间复杂度较高，但实现简单。

代码实现

# 方法 3: 逐行二分查找
class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        for row in matrix:
            # 使用二分查找在当前行中查找目标值
            index = bisect.bisect_left(row, target)
            if index < len(row) and row[index] == target:
                return True
        return False

复杂度分析

  • 时间复杂度：O(m * log n)，其中 m 是矩阵的行数，n 是矩阵的列数。对每一行进行二分查找。
  • 空间复杂度：O(1)，只使用了常数级别的额外空间。

162、寻找峰值

链接：162、寻找峰值

题目描述：
在这里插入图片描述

方法 1

思路：由于左右元素不相同，因此nums的最大值不会在一起，因此找到最大值的index就一定是峰值。

# 方法 1：最大值
class Solution:
    def findPeakElement(self, nums: List[int]) -> int:
        return nums.index(max(nums))

复杂度分析

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

方法 2

在这里插入图片描述
作者：灵茶山艾府

# 方法 2：二分法
class Solution:
    def findPeakElement(self, nums: List[int]) -> int:
        # 初始化左右边界，使用开区间 (-1, len(nums) - 1)
        left, right = -1, len(nums) - 1
        
        # 当开区间不为空时继续搜索
        while left + 1 < right:
            # 计算中间位置
            mid = (left + right) // 2
            
            # 如果中间元素大于其右侧元素，则峰值在左侧（包括mid）
            if nums[mid] > nums[mid + 1]:
                right = mid
            # 否则，峰值在右侧
            else:
                left = mid
        
        # 返回右边界，即峰值元素的索引
        return right

# 作者：灵茶山艾府
# 链接：https://leetcode.cn/problems/find-peak-element/solutions/1987497/by-endlesscheng-9ass/
# 来源：力扣（LeetCode）

复杂度分析

  • 时间复杂度：O(log n)，其中 n 是数组的长度。
  • 空间复杂度：O(1)。

33、搜索旋转排序数组

链接：33、搜索旋转排序数组

题目描述：
在这里插入图片描述

方法 1

思考过程：

  1. 初始化左右边界：
    • 初始化 left 为数组的起始索引 0，right 为数组的结束索引 len(nums) - 1。
  2. 二分查找：
    • 计算中间位置 mid。
    • 判断 nums[mid] 是否等于目标值 target，如果是则返回 mid。
    • 如果 nums[mid] 不等于目标值，则需要判断目标值在左半部分还是右半部分。
      • 如果 nums[left] <= nums[mid]，说明左半部分是有序的。
        • 如果 target 在 nums[left] 和 nums[mid] 之间，则在左半部分继续查找，否则在右半部分继续查找。
      • 如果 nums[left] > nums[mid]，说明右半部分是有序的。
        • 如果 target 在 nums[mid] 和 nums[right] 之间，则在右半部分继续查找，否则在左半部分继续查找。
  3. 返回结果：
    • 如果在整个查找过程中没有找到目标值，则返回 -1。
# 方法 1：二分类
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums) - 1
        
        while left <= right:
            mid = (left + right) // 2
            
            if nums[mid] == target:
                return mid
            
            # 判断左半部分是否有序
            if nums[left] <= nums[mid]:
                # 判断目标值是否在左半部分
                if nums[left] <= target < nums[mid]:
                    right = mid - 1
                else:
                    left = mid + 1
            else:
                # 判断目标值是否在右半部分
                if nums[mid] < target <= nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1
        
        return -1

代码解释

  1. 初始化边界：
    • left 初始化为 0，表示数组的起始索引。
    • right 初始化为 len(nums) - 1，表示数组的结束索引。
  2. 循环查找：
    • 使用 while left <= right 循环，确保查找范围有效。
    • 计算中间位置 mid，使用公式 mid = (left + right) // 2。
    • 如果 nums[mid] 等于目标值 target，则返回 mid。
    • 判断左半部分是否有序：
      • 如果 nums[left] <= nums[mid]，说明左半部分是有序的。
        • 如果目标值 target 在 nums[left] 和 nums[mid] 之间，则在左半部分继续查找，更新右边界 right = mid - 1。
        • 否则，在右半部分继续查找，更新左边界 left = mid + 1。
      • 如果 nums[left] > nums[mid]，说明右半部分是有序的。
        • 如果目标值 target 在 nums[mid] 和 nums[right] 之间，则在右半部分继续查找，更新左边界 left = mid + 1。
        • 否则，在左半部分继续查找，更新右边界 right = mid - 1。
  3. 返回结果：
    • 如果在整个查找过程中没有找到目标值，则返回 -1。

复杂度分析

  • 时间复杂度：O(log n)，其中 n 是数组的长度。二分查找每次将搜索范围减半。
  • 空间复杂度：O(1)

方法 2

这种方法是最直接的，通过遍历整个数组来查找目标值。虽然简单，但时间复杂度为 O(n)，不符合题目要求。

# 方法 2：线性扫描法
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        for i in range(len(nums)):
            if nums[i] == target:
                return i
        return -1

复杂度分析

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)
久莜
关注
Java岗大厂面试百日冲刺 - 日积月累，每日三题【Day33】—— 手撸算法2
陈哈哈的菜园子
08-08 1万+
百日闭关修炼，每日三道高频面试题。一起冲进大厂！算法是敲门砖，多的就不说了，快上车！
力扣算法题-数组-Day1|704.二分查找、27.去除元素
m0_71815134的博客
02-08 100
力扣算法题——704.二分查找、27.去除元素
【Leetcode】每日一题打卡（64）
weixin_61639349的博客
09-14 400
只做简单和中等 困难求大佬 坚持就是胜利
＜LeetCode天梯＞Day036 第一个错误的版本（二分查找法） | 初级算法 | Python
车手只需要车和手，压力来自轮胎
11-30 345
????作者简介：大家好，我是车神哥，府学路18号的车神???? ⚡About—>车神：从寝室到实验室最快3分钟，最慢3分半（那半分钟其实是等红绿灯） ????个人主页：应无所住而生其心的博客_府学路18号车神_CSDN博客 ????点赞➕评论➕收藏 == 养成习惯（一键三连）???? ????本系列主要以刷LeetCode（力扣）网站的各类题为标准，实现自我能力的提升为目标⚡ ⚡希望大家多多支持????~一起加油 ???? 专栏—>《LeetCode天梯》 其他专栏： 《Neural N
力扣——二分法总结（python）（csdn）————程序.pdf
12-05
在给定的文件中，提到了几个使用二分法解决的力扣（LeetCode）编程题目。 首先，力扣704“二分查找”题目的目标是在一个有序整数数组`nums`中找到目标值`target`的索引。代码示例中展示了两种解决方案。第一种方法...
力扣面试经典150题力扣面试经典150题
11-21
"力扣面试经典150题"是一系列精选的题目，旨在帮助面试者熟悉常见的面试问题，提升解决问题的能力。 在LeetCode中，面试经典150题主要分为以下几个类别： 1. **数组**：数组是最基础的数据结构，涉及到的问题包括...
力扣每日一题——1475 商品折扣的最终价格
qq_45057290的博客
09-06 124
个人记录
5月4日力扣每日一题——1473. 粉刷房子 III
mumei的博客
05-05 137
5月4日力扣每日一题——1473. 粉刷房子 III 题解 算是比较常见的dp。 状态 dp[i][j][k]：前i个房子，第i个房子涂成j，街区数为k的最小花费 状态转移方程 if(house[i]==0) dp[i][j][k]=min(dp[i-1][l][k-1],dp[i-1][j][k]) (l!=j) else dp[i][house[i]][k]=min(dp[i][house[i]]) 边界条件 dp[0][i][0]=0 代码 class Solution { public: i
力扣链表题技巧——虚拟头结点
toutu10086的博客
02-09 235
刷力扣链表题的一个小技巧
Java企业面试题3
最新发布
m0_74972727的博客
09-15 557
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
面试真题 | web自动化关闭浏览器，quit()和close()的区别
NHB234567的博客
09-13 314
关闭所有的浏览器窗口，销毁driver操作，则需要使用的是quit方法；当打开了多个窗口，只想要关闭非最后一个窗口的时候，使用的是close方法。这些资料，对于【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴上万个测试工程师们走过最艰难的路程，希望也能帮助到你！close():只关闭当前的浏览器标签页，如果当前浏览器标签页剩下最后一个，则所有标签页面退出。是否编写过对应浏览器退出的测试用例。quit():所有的浏览器窗口退出。关闭当前的标签页，其他窗口不退出。退出当前所有的窗口；
【OJ刷题】快慢指针问题
道阻且长，行则将至，关注我，和我一起奔赴下一场山海!
09-13 558
写在开头现在您看到的是我的结论或想法，但在这背后凝结了大量的思考、经验和讨论 5. 夹带私货若你能看到看到这篇文章且能看到这，则说明你我有缘，留个关注吧，后面还会接着计算机408、底层原理、开源项目、以及数据、后端研发相关、实习、笔试/面试、秋招/春招、各种竞赛相关、简历相关、考研、学术相关……，祝你我变得更强好的，到此为止啦，祝您变得更强
JVM面试真题总结（六）
月伴飞鱼
09-11 693
不过，对于新生代这样对象存活率较低的区域，复制算法通常是一种非常高效的垃圾收集方式。当Eden区满时，就会触发一次Minor GC，GC会检查Eden区中的所有对象。因此，现代的垃圾收集器通常不单独使用标记-清除算法，而是结合其他算法一起使用。GC（垃圾收集）的标记整理算法是一种用于回收垃圾对象并释放内存空间的方法。复制算法是垃圾收集中的一种常见算法，它主要被用于新生代的垃圾回收。在实际的应用场景中，标记-整理算法通常用于堆内存的垃圾回收。不过，它的代价是需要移动对象，这会增加一定的开销。
华雁智科前端面试题
weixin_56370772的博客
09-14 440
此博客记录，秋招第一次很简单的手撕代码笔试题。哭死，希望能给个面试机会。一定能找到工作的。加油，多积累面试经验，借用人民日报今年的广告语，“请你努力，为了你自己。祝大家秋招都能收到offer。
宏任务和微任务+超全面试真题（持续更新ing
weixin_63681863的博客
09-11 998
微任务和宏任务是在异步编程中经常使用的概念，用于管理任务的执行顺序和优先级。微任务通常比宏任务具有更高的优先级。
【Java面试】第八天
m0_56608748的博客
09-10 749
除了Spring官方提供的这些作用域以外，我们还可以自定义我们自己的作用域，Spring提供了这方面的支持。要自定义一个 Spring 的作用域，需要实现接口。这个接口要求实现几个关键方法来管理 Bean 的生命周期。@Nullable@Nullable@Nullable接下来，我们需要实现接口的方法，例如 get（创建或检索 Bean 实例）、remove（销毁 Bean 实例）等。
软件测试工程师面试整理-测试工具
不务正业的猿
09-13 645
通常，一个项目可能需要使用多种工具结合使用，以覆盖不同的测试需求，如功能测试、性能测试、安全测试和自动化测试。根据不同的测试类型和需求，有许多专业的工具可供选择。特点：支持多种浏览器（如Chrome、Firefox），可以使用多种编程语言（如Java、Python、C#）编写测试脚本。特点：基于关键字的测试，易于扩展，支持与Selenium、Appium等工具集成。特点：支持RESTful API的请求构建和测试，易于使用，支持自动化测试。用途：集成式的自动化测试工具，支持Web、API、移动应用的测试。
前端CSS面试常见题
m0_73761441的博客
09-11 559
前端CSS面试常见题，包含边界塌陷、bfc、csshack、src和href的区别、浏览器内核、兼容性问题、flex和grid优劣对比
Java代码自动评分项目中如何检查代码是否实现了题目要求，怎么判断实现了得分，不实现扣分
03-27
在Java代码自动评分项目中，可以通过以下方式检查代码是否实现了题目要求： 1. 使用正则表达式或其他方式检查代码是否包含指定的关键字、变量、方法等。 2. 执行代码并检查输出结果是否符合预期。 3. 使用代码静态分析工具（如Checkstyle、PMD、FindBugs等）检查代码风格、命名规范、代码质量等。 判断是否实现了得分，可以根据题目要求设置不同的评分规则，例如： 1. 对于必须实现的要求，可以设置一定的基础分数，如果实现了则获得全部基础分数，否则不得分。 2. 对于可选实现的要求，可以设置一定的额外分数，如果实现了则获得额外分数，否则不得分。 3. 对于部分实现的要求，可以根据实现程度给予相应的分数。 扣分也可以根据题目要求设置相应的规则，例如： 1. 对于不符合规范的代码风格、命名规范等，可以扣除一定的分数。 2. 对于代码中出现的错误、异常等，可以扣除一定的分数。 3. 对于未实现的要求，可以扣除相应的分数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值