LeetCode 题集：二分搜索（二）

最新推荐文章于 2024-06-02 22:16:46 发布
最新推荐文章于 2024-06-02 22:16:46 发布
阅读量760 收藏
点赞数
分类专栏： LeetCode 算法与数据结构 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhang_0702_china/article/details/121163332
版权

本文介绍 LeetCode 题集中，有关二分搜索的问题。

LeetCode 其他有关二分搜索的问题：
LeetCode 题集：二分搜索（一）


33. Search in Rotated Sorted Array（搜索旋转排序数组）


问题描述

LeetCode 33 问题描述

思路与代码


在本题中，由于输入数组经过了切分和重新拼接，因此可以先通过二分搜索找到切分点，进而判断目标值可能出现在前段还是后段，再进行二分搜索即可。具体情形如下：

  • 若无切分，数组最小值为第一个元素
  • 若有切分，数组最小值为切分后段的第一个元素

代码如下：

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        """ get start and end point """

        # case 1: actually no rotating
        if nums[-1] > nums[0]:
            start, end = 0, len(nums) - 1

        # case 2: rotated
        else:
            # get the cut point
            start, end = 0, len(nums) - 1
            while start + 1 < end:
                mid = int((start + end) / 2)
                if nums[mid] > nums[start]:
                    start = mid
                else:
                    end = mid
            left_start, left_end, right_start, right_end = 0, end - 1, end, len(nums) - 1
            start = left_start if target >= nums[0] else right_start
            end = left_end if target >= nums[0] else right_end

        """ binary search """

        while start + 1 < end:
            mid = int((start + end) / 2)
            if nums[mid] == target:
                return mid

            elif nums[mid] < target:
                start = mid
            else:
                end = mid

        if nums[start] == target:
            return start
        elif nums[end] == target:
            return end
        else:
            return -1

运行效果：
LeetCode 33 运行效果 1

此外，还有一种无需确定切分点的方法，仅根据切分拼接后的数组特性即可实现二分搜索，代码如下：

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        start, end = 0, len(nums) - 1
        while start + 1 < end:
            mid = int((start + end) / 2)
            if nums[mid] == target:
                return mid

            elif nums[mid] < nums[end]:  # 如未发生切分拼接，则只有该 elif 起作用，后面的 else 不起作用
                if nums[mid] <= target <= nums[end]:
                    start = mid
                else:
                    end = mid

            else:
                if nums[start] <= target <= nums[mid]:
                    end = mid
                else:
                    start = mid

        if nums[start] == target:
            return start
        elif nums[end] == target:
            return end
        else:
            return -1

运行效果：
LeetCode 33 运行效果 2


81. Search in Rotated Sorted Array II（搜索旋转排序数组 II）


问题描述

LeetCode 81 问题描述

思路与代码


本题为前一题的变体，但由于数组中可能存在重复值，很难在优于 O ( n ) O(n) O(n) 的前提下确定切分点，甚至很难在优于 O ( n ) O(n) O(n) 的前提下判断数组是否经过切分：

  • 数组首项小于末项，一定没有经过切分；
  • 数组首项大于末项，一定经过了切分；
  • 数组的首项和末项相等，不确定，例： [ 1 , 1 , 1 ] , [ 1 , 2 , 1 ] , [ 3 , 1 , 3 ] [1, 1, 1], [1, 2, 1], [3, 1, 3] [1,1,1],[1,2,1],[3,1,3]

基于上述困难，本题参考前一题的第二种方法进行修改。

代码如下：

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        start, end = 0, len(nums) - 1
        while start <= end:  # 由于循环中 start 和 end 至少有一个会移动，因此循环条件可以设为 <=
            mid = int((start + end) / 2)
            if nums[mid] == target:
                return True

            elif nums[mid] < nums[end]:
                if nums[mid] <= target <= nums[end]:
                    start = mid + 1
                else:
                    end = mid - 1

            elif nums[mid] > nums[end]:
                if nums[start] <= target <= nums[mid]:
                    end = mid - 1
                else:
                    start = mid + 1

            else:  # 单独处理 nums[mid] = nums[end] 的情况，以应对重复值
                end -= 1

        return False

上述代码在循环体中对 mid 和 end 进行比较，对应地，也可以对 mid 和 start 进行比较，
代码如下：

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        start, end = 0, len(nums) - 1
        while start <= end:  # 由于循环中 start 和 end 至少有一个会移动，因此循环条件可以设为 <=
            mid = int((start + end) / 2)
            if nums[mid] == target:
                return True

            elif nums[start] < nums[mid]:
                if nums[start] <= target < nums[mid]:
                    end = mid - 1
                else:
                    start = mid + 1

            elif nums[start] > nums[mid]:
                if nums[mid] < target <= nums[end]:
                    start = mid + 1
                else:
                    end = mid - 1

            else:  # 单独处理 nums[mid] = nums[end] 的情况，以应对重复值
                start += 1

        return False

运行效果：
LeetCode 81 运行效果


153. Find Minimum in Rotated Sorted Array（寻找旋转排序数组中的最小值）


问题描述

LeetCode 153 问题描述 I
LeetCode 153 问题描述 II

思路与代码


本题思路可参考本文第一题（LeetCode 33），即通过二分搜索找到数组的切分点。

代码如下：

class Solution:
    def findMin(self, nums: List[int]) -> int:
        # actually no rotating
        if nums[-1] > nums[0]:
            return nums[0]
            
        # get the cut point
        start, end = 0, len(nums) - 1
        while start + 1 < end:
            mid = int((start + end) / 2)
            if nums[mid] > nums[start]:
                start = mid
            else:
                end = mid
        return nums[end]

运行效果：
LeetCode 153 运行效果


154. Find Minimum in Rotated Sorted Array II（寻找旋转排序数组中的最小值 II）


问题描述

LeetCode 154 问题描述

思路与代码


本题为前一题的变体，区别在于本题允许数组中存在重复数字。当存在重复数字时，在二分搜索的循环体中，须对 mid 与端点相等的情况进行单独处理；此外，由于所求为最小值，故将 mid 与 end 相比较，若相等，将 end 自减 1，使循环继续而不影响结果。

代码如下：

class Solution:
    def findMin(self, nums: List[int]) -> int:
        # actually no rotating
        if nums[-1] > nums[0]:
            return nums[0]

        # get the minimum
        start, end = 0, len(nums) - 1
        while start + 1 < end:
            mid = int((start + end) / 2)

            if nums[mid] < nums[end]:
                end = mid
            elif nums[mid] > nums[end]:
                start = mid + 1
            else:  # 单独处理 nums[mid] = nums[end] 的情况，以应对重复值
                end -= 1

        return min(nums[start], nums[end])

此处需要注意的是，输出的最小值所在的位置并不一定是切分点。

运行效果：
LeetCode 154 运行效果


4. Median of Two Sorted Arrays（寻找两个正序数组的中位数）


问题描述

LeetCode 4 问题描述 I
LeetCode 4 问题描述 II

思路与代码


本题的难度在于如何在 O ( l o g ( m + n ) ) O(log(m + n)) O(log(m+n)) 的时间复杂度下求解。

思路参考官方题解：
LeetCode 4 官方题解

LeetCode 4 官方题解 I
LeetCode 4 官方题解 II
LeetCode 4 官方题解 III
LeetCode 4 官方题解 IV
LeetCode 4 官方题解 V
代码如下：

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        def get_kth_element(k):  # k: the kth min number
            index_start_1, index_start_2 = 0, 0
            while True:
                # special cases, return
                # case 1: array 1 run out
                if index_start_1 == m:
                    return nums2[index_start_2 + k - 1]
                # case 2: array 2 run out
                if index_start_2 == n:
                    return nums1[index_start_1 + k - 1]
                # case 3: k run out
                if k == 1:
                    return min(nums1[index_start_1], nums2[index_start_2])

                # normal iterations
                index_pivot_1 = min(index_start_1 + k // 2 - 1, m - 1)
                index_pivot_2 = min(index_start_2 + k // 2 - 1, n - 1)
                pivot_1, pivot_2 = nums1[index_pivot_1], nums2[index_pivot_2]
                if pivot_1 <= pivot_2:  # update k and start point of an array
                    k -= index_pivot_1 - index_start_1 + 1
                    index_start_1 = index_pivot_1 + 1
                else:
                    k -= index_pivot_2 - index_start_2 + 1
                    index_start_2 = index_pivot_2 + 1
        
        m, n = len(nums1), len(nums2)
        length = m + n
        if length % 2:  # odd amount
            return get_kth_element((length + 1) // 2)
        else:  # even amount
            return (get_kth_element(length // 2) + get_kth_element(length // 2 + 1)) / 2

运行效果：
LeetCode 4 运行效果

星海浮生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
leetcode:leetcode 题集
05-11
引言 欢迎大家 fork and star 时间线 2019-06-01 至 2019-08-17 leetcode 300题, 主要集中树, 回溯, 数组, 字符串, 贪心, 动态规划几个专题。...leetcode 600题, 主要是leetcode 周赛和虚拟竞赛, 周赛(2-3)/4, 虚
LeetCode-1:LeetCode题集
07-03
这是我在的刷题集，详情参见__注释__。 未完待续！！！ 已完成 27. Remove Element 14. Longest Common Prefix 9. Palindrome Number 7. Reverse Integer 1. Two Sum License The MIT License (MIT)
Python 每日一练 二分查找 搜索旋转排序数组 详解
m0_62277756的博客
01-28 1564
问题描述： Python 榴芒解法：（bushi) class Solution: def search(self, nums: List[int], target: int) -> int: return nums.index(target) if target in nums else -1 这榴芒解法玩玩可以（bushi） 二分解法（重中之重）： ...
【Python刷题Leetcode】二分查找与二叉排序树
木尧大兄弟
07-19 318
class Solution: def searchInsert(self, nums: List[int], target: int) -> int: begin=0 end=len(nums)-1 while begin<=end: mid = (begin+end)//2 if nums[mid]==target: return mid ...
垃圾小白羊leetcode刷题记录1
cmaster1219的博客
06-01 541
我的解法： def twoSum(self, nums: List[int], target: int) -> List[int]: for i, num in enumerate(nums): for j in range(i+1,len(nums)): if nums[j] == target-num: return [i,j] 两层循环，时间复杂度O(n2) 大佬解法： def twoSum(self, nums.
解决：python3类定义写法，(self, nums: List[int]) -> int:
热门推荐
ZYYRWish_97的博客
05-10 2万+
class Solution: def arrayPairSum(self, nums: List[int]) -> int: return sum(sorted(nums)[0::2]) 这段代码是LeetCode上的，我没有接触过这种定义写法。 这是新增的语法，为了说明参数和返回值的数据类型。不过仅仅的给人看的，实际上程序并不检查是否是相符的。 故意写错了，一样可以正常运行。 def fun(x: int) -> str: return [x] >&
LeetCode 题集：二分搜索（一）
星海浮生
11-05 749
LeetCode 278. First Bad Version（第一个错误的版本） 35. Search Insert Position（搜索插入位置） 74. Search a 2D Matrix（搜索二维矩阵） 240. Search a 2D Matrix II（搜索二维矩阵 II） 69. Sqrt(x)
Leetcode二分查找合集
qq_43523544的博客
10-10 521
力扣二分查找合集（C++）
LeetCode题集
11-15 125
水题：就是模拟运算的简单题，用到的算法知识较少 剑指 Offer 10- II. 青蛙跳台阶问题、Leetcode的Go实现_李歘歘的博客-CSDN博客 剑指 Offer II 068. 查找插入位置、Leetcode的Go实现_李歘歘的博客-CSDN博客 剑指 Offer 05. 替换空格、Leetcode的Go实现_李歘歘的博客-CSDN博客 剑指 Offer 06. 从尾到头打印链表、Leetcode的Go实现_李歘歘的博客-CSDN博客 普通题：有一定的算法技巧，但是不涉及高深的算法知识
【双指针】LeetCode题集
cgb18thu的博客
02-16 75
双指针力扣题目集
Leetcode题集
YoutiaoNo2的博客
09-30 160
Leetcode树(Tree)分治(Divide and Conquer)链表(Linked List)二叉搜索树(BST) 树(Tree) id name Difficulty Similar problems Comments 94 Binary Tree Inorder Traversal 1 144,145,429,589,590,987,1302 traversal 100 Same Tree 2 101,104,110,111,572,965 102 Binary Tr
leetcode中国-LeetCode101:《LeetCode101》例题及练习题
06-29
二分查找 例题 69 x 的平方根 34 在排序数组中查找元素的第一个和最后一个位置 81 搜索旋转排序数组2 练习 154 寻找旋转排序数组中的最小值 540 有序数组中的单一元素 4 寻找两个有序数组的中位数 总结：求开方...
leetcode:leetcode刷题:pencil:
05-02
数组 | 二分查找 5 Medium 字符串 | 动态规划 7 反转整数 C++ Note Easy 数学 | 鲁棒性 8 字符串转整数(atoi) C++ Note Medium 字符串 | 数学 | 鲁棒性 10 正则表达式匹配 C++ Note Hard 字符串 | 动态规划 11 盛...
leetcode 704 二分查找
06-24
虽然题目是很简单，但是对于细节进行了补充
【力扣刷题 动态规划】LeetCode 139 单词拆分、LeetCode 300 最长递增子序列 ✌
最新发布
Hou_lang_LJ的博客
06-02 974
🐧①LeetCode 139 单词拆分、LeetCode 300 最长递增子序列 🖊😄✌
leetcode5 最长回文子串
2402_84062759的博客
06-02 413
给你一个字符串s，找到s中最长的 回文 子串。"bab""aba" 同样是符合题意的答案。
代码随想录训练营Day56：Leetcode647、516
maybeyaluokenai的博客
05-31 213
Leetcode647、516
159.二叉树：二叉树的层平均值（力扣）
weixin_63779802的博客
05-31 356
代码同样使用了广度优先搜索（BFS）的方法。主要思路是使用一个队列来进行层次遍历，在每一层遍历的时候，计算所有节点的值的总和以及节点的数量，然后用总和除以节点数量得到平均值。这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储整个树的节点。代码是解决“二叉树的层平均值”问题的C++代码，这个问题要求计算二叉树中每一层的节点值的平均值，并返回一个包含这些平均值的列表。
leetcode 101:和你一起你轻松刷题(c++) pdf
07-30
"leetcode 101:和你一起你轻松刷题(c )"是一本关于刷题的 pdf 电子书。LeetCode 是一个流行的在线编程平台，提供了许多编程问题和算法题供程序员练习和挑战。这本电子书的目的是通过提供答案和解题思路帮助读者更...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值