【图解算法数据结构】（六）查找算法

最新推荐文章于 2023-03-23 18:24:21 发布
最新推荐文章于 2023-03-23 18:24:21 发布
阅读量277 收藏
点赞数
分类专栏： 【LeetCode笔记】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39478403/article/details/119281896
版权

目录

一、剑指 Offer 03. 数组中重复的数字

1.1 题求

1.2 求解

二、剑指 Offer 04. 二维数组中的查找

2.1 题求

2.2 求解

2.3 解答

三、剑指 Offer 11. 旋转数组的最小数字 ☆

3.1 题求

3.2 求解

3.3 解答

四、剑指 Offer 50. 第一个只出现一次的字符

4.1 题求

4.2 求解

4.3 解答

五、剑指 Offer 53 - I. 在排序数组中查找数字 I

1.1 题求

1.2 求解

1.3 解答

六、剑指 Offer - II. 0～n-1 中缺失的数字

6.1 题求

6.2 求解

6.3 解答

一、剑指 Offer 03. 数组中重复的数字

1.1 题求

1.2 求解

法一：哈希集合

# 36ms - 90.77%
class Solution:
    def findRepeatNumber(self, nums: List[int]) -> int:
        repeat = set()
        for n in nums:
            if n in repeat:
                return n
            repeat.add(n)

法二：哈希表

# 36ms - 97.00%
class Solution:
    def findRepeatNumber(self, nums: List[int]) -> int:
        count = [0] * len(nums)
        for n in nums:
            if count[n] > 0:
                return n
            count[n] += 1

官方说明

class Solution:
    def findRepeatNumber(self, nums: [int]) -> int:
        dic = set()
        for num in nums:
            if num in dic: return num
            dic.add(num)
        return -1

# 40ms - 91.91%
class Solution:
    def findRepeatNumber(self, nums: [int]) -> int:
        i = 0
        while i < len(nums):
            # 正好在位置上, 继续推进
            if nums[i] == i:
                i += 1
                continue
            # 重复
            if nums[nums[i]] == nums[i]: 
                return nums[i]
            # 交换
            nums[nums[i]], nums[i] = nums[i], nums[nums[i]]
        return -1

参考资料：

《剑指 Offer 第二版》

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/59bjss/

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/59jyzd/

二、剑指 Offer 04. 二维数组中的查找

2.1 题求

2.2 求解

法一：二分搜索

# 32ms - 96.22%
class Solution:
    def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
        
        def bisect(arr, left, right):
            ''' 二分查找 '''
            while left <= right:
                mid = (left + right) // 2
                if arr[mid] < target:
                    left = mid + 1
                elif arr[mid] > target:
                    right = mid - 1
                else:  # arr[mid] == target:
                    return True
            return False   
        
        # 行数  
        m = len(matrix) 
        if not m:  # m == 0
            return False
        
        # 列数
        n = len(matrix[0]) 
        if not n:  # n == 0
            return False
        
        # 行选择
        for i in range(m):
            if target < matrix[i][0]:  # 比第 i 行的最小值还要小, 说明目标不存在
                return False
            elif target > matrix[i][-1]:  # 比第 i 行的最大值还要大, 直接跳过搜素
                continue
            if bisect(matrix[i], 0, n-1):  # 第 i 行范围正常, 二分查找
                return True
        return False

官方说明 

# 32ms - 96.22%
class Solution:
    def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
        # 从矩阵左下角开始遍历 !!! (最重要的起点, 同理右上角也可以作为起点, 规则相反)
        i, j = len(matrix)-1, 0  # 行、列起点
        while i >= 0 and j < len(matrix[0]):
            if matrix[i][j] > target:  # target 可能在当前位置上方, 走过第 i 行元素
                i -= 1
            elif matrix[i][j] < target:  # target 可能在当前位置右侧, 走过第 j 列元素
                j += 1
            else:  # 找到 target
                return True
        return False

2.3 解答

参考资料：

《剑指 Offer 第二版》

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5v76yi/

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5vl81e/

三、剑指 Offer 11. 旋转数组的最小数字 ☆

3.1 题求

3.2 求解

测试用例

[1, 2, 3, 4, 5]
[2, 3, 4, 5, 1]
[3, 4, 5, 1, 2]
[4, 5, 1, 2, 3]
[5, 1, 2, 3, 4] 
[0, 1, 2, 2, 2] 
[2, 0, 1, 2, 2] 
[2, 2, 0, 1, 2] 
[2, 2, 2, 0, 1] 
[1, 2, 2, 2, 0]
[1]
[0, 1]
[1, 0]
[1, 1]
[1, 1, 1]
[10, 1, 10, 10, 10]
[6, 1, 6, 6, 6, 6, 6]
[6, 6, 6, 6, 6, 1, 6]

法一：二分搜索 + 线性搜索

# 32ms - 87.32%
class Solution:
    def minArray(self, numbers: List[int]) -> int:
        left = 0
        right = len(numbers)-1
        while left < right:
            mid = (left + right) // 2     
            if numbers[mid] > numbers[right]:  # min 在 mid+1, right
                left = mid + 1
            elif numbers[mid] < numbers[right]:  # min 在 left, mid
                right = mid
            else:  # min 不确定在哪里, 直接线性搜索  left, right-1 或 left+1, right
                return min(numbers[left:right])
        return numbers[left]

官方说明

class Solution:
    def minArray(self, numbers: [int]) -> int:
        i, j = 0, len(numbers) - 1
        while i < j:
            m = (i + j) // 2  # // 会向下取整, 从而有：i <= m < j  
            if numbers[m] > numbers[j]: 
                i = m + 1
            elif numbers[m] < numbers[j]: 
                j = m
            else: 
                j -= 1
        return numbers[i]

class Solution:
    def minArray(self, numbers: [int]) -> int:
        i, j = 0, len(numbers)-1
        while i < j:
            m = (i + j) // 2
            if numbers[m] > numbers[j]: 
                i = m + 1
            elif numbers[m] < numbers[j]: 
                j = m
            else: 
                return min(numbers[i:j])
        return numbers[i]

3.3 解答

参考资料：

《剑指 Offer 第二版》

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/50xofm/

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5055b1/

四、剑指 Offer 50. 第一个只出现一次的字符

4.1 题求

4.2 求解

法一：哈希表

# 116ms - 43.72%
class Solution:
    def firstUniqChar(self, s: str) -> str:
        # 时间复杂度至少是 O(n) 因为直到遍历完最后一个才可能确定首个单字符
        # 所以优化的关键在于遍历完所有字符后以最快速度确定首个单字符
        
        # 字频哈希表
        hashmap = {}  # key-char : value-nums
        
        # 字符出现次数计数
        for c in s:
            if hashmap.get(c) is None:
                hashmap[c] = 1
            else:
                hashmap[c] += 1
                
        # 搜索首个单字符
        for c in s:
            if hashmap[c] == 1:
                return c
        
        # 没有不重复的首个单字符
        return " "

官方说明

# 64ms - 97.39
class Solution:
    def firstUniqChar(self, s: str) -> str:
        dic = {}
        for c in s:
            dic[c] = not c in dic  # 使用 True 和 Fasle 状态代替计数, 好特别多
        for c in s:
            if dic[c]: 
                return c
        return ' '

# 68ms - 95.15%
class Solution:
    def firstUniqChar(self, s: str) -> str:
        dic = collections.OrderedDict()  # {}
        for c in s:
            dic[c] = not c in dic
        for k, v in dic.items():
            if v: 
                return k
        return ' '

4.3 解答

参考资料：

《剑指 Offer 第二版》

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5viisg/

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5vu0zv/

五、剑指 Offer 53 - I. 在排序数组中查找数字 I

1.1 题求

1.2 求解

法一：二分搜索 + 线性搜素

# 32ms - 80.64%
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        # target 计数器
        summ = 0
        
        # 二分搜索找到 target 作为起点
        n = len(nums)
        left = 0
        right = n - 1
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] > target:
                right = mid - 1
            elif nums[mid] < target:
                left = mid + 1
            else:
                summ += 1
                break
        
        # 因越界而退出循环, 计数为 0
        if left > right:
            return summ
        
        # 因找到目标而退出循环, 开始计数
        # 向右
        rhs = mid + 1
        while rhs < n and nums[rhs] == target:
            summ += 1  # 计数加一
            rhs += 1  # 右移一步
        # 向左
        lhs = mid - 1
        while lhs > -1 and nums[lhs] == target:
            summ += 1  # 计数加一
            lhs -= 1  # 左移一步
        
        return summ

官方说明 

# 20ms - 99.86%
class Solution:
    def search(self, nums: [int], target: int) -> int:
        # 搜索右边界 right
        i, j = 0, len(nums) - 1
        while i <= j:
            m = (i + j) // 2
            if nums[m] <= target:  # 右边界
                i = m + 1
            else: 
                j = m - 1
        right = i
        
        # 若数组中无 target ，则提前返回
        if j >= 0 and nums[j] != target: 
            return 0
        
        # 搜索左边界 left
        i = 0
        while i <= j:
            m = (i + j) // 2
            if nums[m] < target:  
                i = m + 1
            else:  # nums[m] >= target  # 左边界 
                j = m - 1
        left = j
        
        return right - left - 1

# 28ms - 93.85%
class Solution:
    def search(self, nums: [int], target: int) -> int:
        def helper(tar):
            i, j = 0, len(nums)-1
            while i <= j:
                m = (i + j) // 2
                if nums[m] <= tar:  # 寻找右边界
                    i = m + 1
                else: 
                    j = m - 1
            return i
        # 右边界作差, 思路非常好
        return helper(target) - helper(target-1)

1.3 解答

参考资料：

《剑指 Offer 第二版》

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5874p1/

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/58lgr7/

六、剑指 Offer - II. 0～n-1 中缺失的数字

6.1 题求

6.2 求解

法一：二分搜索

# 32ms - 93.44%
class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        m = len(nums)  # m+1=n个数字中, 每个数字都在范围0～n-1之内
        
        # 首尾缺失检查
        if nums[0] != 0:
            return 0
        elif nums[-1] != m:  # nums[m-1]
            return m
        
        # 中间缺失检查
        left = 0
        right = m - 1
        while left < right:  # left == right 时退出, 此时索引在缺失值的位置上
            mid = (left + right) // 2
            # case1: nums[mid] 过大, 说明缺失值在中、左侧
            if nums[mid] > mid:
                right = mid
            # case2: nums[mid] 正常, 说明缺失值在右侧
            elif nums[mid] == mid:
                left = mid + 1
                
        return right  # or return left

简化

# 32ms - 93.44%
class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        left = 0
        right = len(nums) - 1
        while left <= right: 
            mid = (left + right) // 2
            if nums[mid] > mid:
                right = mid - 1
            elif nums[mid] == mid:
                left = mid + 1
                
        return left

官方说明 

# 32ms - 92.44%
class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        i, j = 0, len(nums)-1
        while i <= j:
            m = (i + j) // 2
            if nums[m] == m: 
                i = m + 1
            else: 
                j = m - 1
        return i

6.3 解答

参考资料：

《剑指 Offer 第二版》

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/58iqo5/

https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/58ut96/

《算法图解》
遇见1995
08-25 1128
第 01 章——算法简介 二分查找（有序序列） 大O表示法：表示最坏条件下，操作数的增速 常见大O运行时间（快到慢） O（logn）：对数时间，二分查找 O（n）：线性时间，简单查找 O（n*logn)：快速排序 O（n^2）：选择排序 O（n！）：旅行商问题 实例 旅行商问题：前往n个地点，总旅程的最短路线。   第 02 章——选择排序 数组：内存连续，查询快，增删元素...
算法图解
qq_37501555的博客
03-06 3033
《算法图解》各章学习 1、算法简介 二分法 二分查找法，用于有序元素列表，以一半为界分开，确定元素在哪一部分，继续前述操作。速度最快，包含n个元素时为 $ \log_2 n$ 大O表示法 用于表示算法的速度，O()。真正的速度需要乘以时间常数c，一般分析时不考虑。 2、选择排序 数组 数组在内存中储存的信息是连在一起的，方便读取操作。 链表 链表的信息在内存中是无序的，下一个内存地址由上一个内存中的信息给出，方便插入和删除操作。 选择排序 不断遍历整个无序列表，将元素有序排列出来，速度为O(n×n)或O(
数据结构：折半查找/二分查找算法，详解，图解 -- 数据结构算法集
九瓜的博客
06-05 9093
给出一个list和一个元素，判断出list中是否存在该元素 浅短理解： 折半查找算法是对于有序的序列而言的，每次查找后折半，大概缩短了一半的查找区间，是一种效率较高的查找算法。 要求： list必须是顺序结构，且按照关键词大小进行有序排列。 思路： 在有序序列中查找元素，每次取序列中间的元素，如果与要查找元素相等，程序结束； 如果查找元素大于中间元素，则取中间元素后面的序列再进行如上的查找； 如果查找元素小于中间元素，则取中间元素前面的序列再进行如上的查找； 直到找到元素相等，查找成功，或者序列为空，查找失
数据结构与算法 查找算法(线性查找,二分查找,插值查找,斐波那契查找) 附有详细流程分析图!
高级开发者进阶ing... QaQ
06-04 970
工具:IDEA本篇介绍查找算法:重点:线性查找比较简单,就算刚入门也应该会,直接看代码了! 使用: 优缺点分析 优点:缺点:重点:寻找数组必须有序一半一半的找指针记录这里的指针和C中的指针不同这里的指针可以理解为下标,就是找一个临时的数来记录当前位置二分查找只需要3个指针每次值和做比较如果需要寻找的元素 > 中间位置 ,说明 在中间指针右边所以需要将 开始指针 = 中间指针 + 1如果 < 中间位置 ,说明在中间指针左侧所以需要将 结束指针 = 中间指针最终需要找的元素和当前元素相同时候,说明找到了该
数据结构查找算法之平衡二叉树【附Java代码实现，图解】
ppBlog
05-09 397
平衡二叉树，又称为 AVL 树。实际上就是遵循以下两个特点的二叉树： 每棵子树中的左子树和右子树的深度差不能超过 1； 二叉树中每棵子树都要求是平衡二叉树； 平衡因子：每个结点都有其各自的平衡因子，表示的就是其左子树深度同右子树深度的差。平衡二叉树中各结点平衡因子的取值只可能是：0、1 和 -1。 二叉排序树转化为平衡二叉树；当平衡二叉树由于新增数据元素导致整棵树的平衡遭到破坏时，就需要根据实际情况做出适当的调整，假设距离插入结点最近的“不平衡因子”为 a。则调整的规律可归纳为以下 4 种情况
数据结构：小白都能懂的静态查找算法（图文详解）
weixin_46015333的博客
05-25 1457
查找 查找——也叫检索，是根据给定的某个值，在表中确定一个关键字等于给定值的记录或数据元素 关键字——是数据元素中某个数据项的值，它可以标识一个数据元素。 查找方法评价 查找速度； 占用存储空间多少； 算法本身复杂程度； 平均查找长度ASL(Average Search Length)：为确定记录在表中的位置，需和给定值进行比较的 关键字的个数的期望值。
【超全！】图解Java数据结构和算法(共195集)【资料+视频+课件+代码+笔记】
10-13
本教程是使用Java来讲解数据结构和算法，考虑到数据结构和算法较难，授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀...
《剑指 Offer》 Python, Java, C++ 解题代码，LeetBook《图解算法数据结构》配套代码仓.zip
最新发布
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
数据结构和算法PDF文档
06-02
1000多页的算法题解，包含数据结构，排序，查找，递归，回溯算法，二叉树，动态规划，贪心算法，双指针，滑动窗口，前缀和等。
【算法】算法图解
热门推荐
sunny_LI
09-14 1万+
最近看了一本算法入门书——算法图解。封面的插画很好玩儿。最吸引我的还是封面里的一句话：向小说一样有趣的算法入门书。上个封面，大家感受一下：         小说对我来说吸引力是很大的，属于开个头儿就停不下来那种，不看完就难受，熬夜通宵的情况也不是没有（年轻不懂事，熬夜坏身体）。算法是啥，跟数据结构一样抽象难懂啊。难道算法真的也能像小说一样吸引人吗？当时我翻开目录：恩，很全，看的话会学到很
【数据结构与算法】一篇文章彻底搞懂二分查找（思路图解+代码优化）两种实现方式，递归与非递归
黄小黄的博客
03-22 1191
本文带你详细探究二分查找（基本实现 + 优化实现），就二分查找进行了思路图解，并用递归和非递归的两种方式实现了功能。
图解算法—图
u013010473的博客
04-28 281
文章目录图图是什么Python实现图 图 图是什么 图是由节点和边组成的，，用于模拟不同的东西是如何相连的。一个节点可能与众多节点直接相连，这些节点被称为邻居。比如下面的“欠钱图”中：Rama是Alex的邻居，Adit不是Alex的邻居，因为他们不直接相连，但Adit既是Rama的邻居，又是Tom的邻居。 Python实现图 graph = {} graph["you"] = ["alice"...
图解算法入门
2201_75791700的博客
03-23 271
(3).贪心法：核心概念：又称为贪婪算法，从某一起点开始，就是在每一个解决问题步骤中使用贪心原则，即采取在当前状态下最有利或最优化的选择，不断地改进该解答，持续在每一步骤中选择最佳的方法，并且逐步逼近给定的目标，当打到某一步骤不能再继续前进时算法停止，以尽可能地求得更好的解。(6).枚举法：一般这种分析方法和解决问题的方法，得到的结果总是正确的，但是缺点就是速度太慢。(7).回溯法也是枚举法的一种，核心概念：特点是再搜索的过程种寻找问题的解，当发现不满足求解条件，就回溯，尝试别的路径，避免无效搜索。
算法简单易懂图解
weixin_39514724的博客
06-14 326
点击下面的链接，可以快速进入哦 0-0 图解快速排序 图解快速排序 图解归并排序 图解归并排序 图解选择排序 图解选择排序 图解直接插入排序 直接插入排序 ...
尚硅谷图解Java数据结构与算法教程
总结来说，"data-structures.zip" 压缩包内容丰富，不仅涵盖了Java数据结构与算法的理论知识，还提供了大量的实践操作和代码示例，旨在帮助学习者通过图解和编码实践深入理解和掌握数据结构和算法。这对于想要提升...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值