Leetcode 刷题第21天 |98，530，501

最新推荐文章于 2024-08-13 21:21:03 发布
最新推荐文章于 2024-08-13 21:21:03 发布
阅读量23 收藏
点赞数
分类专栏： Leetcode刷题 文章标签： leetcode 算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46690443/article/details/132863874
版权

Leetcode 98 验证二叉搜索树

题目：

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
有效 二叉搜索树定义如下：
节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1：
示例1
输入：root = [2,1,3]
输出：true
示例 2：
示例2

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。
提示：

  • 树中节点数目范围在[1, 1 0 4 10^4 104] 内
  • - 2 31 2^{31} 231 <= Node.val <= 2 31 2^{31} 231 - 1

前言：

什么是二叉搜索树？简单说：根节点大于左子树上的任何值；小于右子树上的任何值。子树同样满足这样的定义。

算法思想：

  • 递归法：
    （1）利用双指针法：
    递归参数：二叉树根节点
    递归结束条件：当当前节点位None，返回；但无返回值，意思是结束当前递归，返回到上一层。
    注： python中return的作用：
    • 返回值（多个值）
    • 结束当前函数

一次递归逻辑：首先是左递归；中序处理pre（cur的前一个节点）的value 是否严格小于cur（当前节点）的value；递归遍历右子树；
（2）定义最小值法：
思路基本与（1）相似，按照二叉排序树的性质，中序遍历的节点是有序的，也就是递增的。也就是用maxValue记录cur节点前的节点的value，即遍历到cur之前节点的最大值。如果cur.value>maxValue，则更新maxValue；否则返回False，即不满足条件。
2. 迭代法：
依然采用中序遍历，在“中序”处理逻辑处类似递归法。

代码实现：

  1. 递归法：
    （1）双指针法：
# 定义树节点
class TreeNode:
    def __init__(self, val=0, left=None, right=None) -> None:
        self.val = val
        self.left = left
        self.right = right

class Solution:
    # 定义全局指针，指向当前节点的前一个节点
    # 此后双指针法遍历二叉树，判断是否是二叉搜索树
    def __init__(self) -> None:
        self.pre = None
    def isValidBST(self, root):
        if root is None:
            return True
        left = self.isValidBST(root.left)
        # self.pre is not None: 意味着递归到最后一个节点不用和root.val比较
        # self.pre.val >= root.val意味着当前“双指针”开始移动了
        if self.pre is not None and self.pre.val >= root.val:
            return False
        self.pre = root
        right = self.isValidBST(root.right)
        return left and right

（2）maxValue方式：

# 定义树结构
class TreeNode:
    def __init__(self, val=0, left=None, right=None) -> None:
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def __init__(self) -> None:
        self.maxValue = float('-inf')

    def isValidBST(self, root):
        if root is None:
            return True

        left = self.isValidBST(root.left)
        if root.val > maxValue:
            maxValue = root.val
        else:
            return False
        right = self.isValidBST(root.right)
        return left and right
  1. 迭代法：
# 定义树结构
class TreeNode:
    def __init__(self, val=0, left=None, right=None) -> None:
        self.val = val
        self.left = left
        self.right = right

# 利用中序遍历的思想
class Solution:
    def isValidBST(self, root):
        if root is None:
            return True
        stack = []
        pre = None
        cur = root

        while cur or stack:
            # 一路向左
            if cur:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                if pre is not None and cur.val <= pre.val:
                    return False
                pre = cur
                cur = cur.right
        return True

Leetcode 530 二叉搜索树的最小绝对差

题目：

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。
差值是一个正数，其数值等于两值之差的绝对值。
示例 1：
实例1
输入：root = [4,2,6,1,3]
输出：1
示例 2：
实例2
输入：root = [1,0,48,null,null,12,49]
输出：1
提示：

  • 树中节点的数目范围是 [2, 1 0 4 10^4 104]
  • 0 <= Node.val <= 1 0 5 10^5 105

算法思路：

一个常规的想法是，开辟一个数组，中序遍历二叉树（为什么中序？利用二叉搜索树的性质）将二叉树的节点都存放在数组中，然后对数组排序。这样做可以，但是有没有更好的办法呢？

  1. 递归法：
    采用双指针法实现。前文说到，二叉搜索树具备良好的性质，因此，中序遍历二叉树是一种很好的选择。
    pre指针：代表当前节点的前一个节点
    cur指针：代表当前节点
    递归参数：当前二叉树节点
    递归结束条件：如果当前节点为None，则返回。
    一次递归逻辑：按照中序遍历的思想，首先遍历左子树。如果pre 不为None，说明要将pre的值和cur的值作差（在绝对值），然后更新最小值。
    最后递归遍历右子树。
  2. 迭代法：
    按照树的中序遍历算法改动即可，逻辑参照递归法。

代码实现：

  1. 递归法：
# 定义树节点
class TreeNode:
    def __init__(self, val=0, left=None, right=None) -> None:
        self.val = val
        self.left = left
        self.right = right

class Solution:
	# 初始化全局最小值和指针
	# 笔者最开始出现的错误是每次递归都定义一个最小值和指针。
    def __init__(self) -> None:
        self.min_value = float('inf')
        self.pre = None

    def traversal(self, cur):
    # 不要求有返回值，但是要求返回到上一层函数
        if cur is None:
            return
        self.traversal(cur.left)
        if self.pre is not None:
            self.min_value = min(self.min_value, (cur.val - self.pre.val))
        self.pre = cur
        self.traversal(cur.right)
        return self.min_value

    def getMinimumDifference(self, root):
        return self.traversal(root)
  1. 迭代法：
# 定义树节点
class TreeNode:
    def __init__(self, val=0, left=None, right=None) -> None:
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def getMinimumDifference(self, root) -> int:
        min_value = float('inf')
        stack = []
        cur = root
        pre = None
        
        while cur or stack:
        	# 一路向左
            if cur:
                stack.append(cur)
                cur = cur.left
             # 直到左节点位空，出栈栈顶元素。也就是返回到上一层节点
            else:
                cur = stack.pop()
                if pre is not None:
                    min_value = min(min_value, (cur.val - pre.val))
                pre = cur
                stack.append(cur.right)
        return min_value

Leetcode 501 二叉搜索树中的众数

题目：

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。
如果树中有不止一个众数，可以按 任意顺序 返回。
假定 BST 满足如下定义：
结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树
示例 1：
示例1
输入：root = [1,null,2,2]
输出：[2]
示例 2：
输入：root = [0]
输出：[0]
提示：

  • 树中节点的数目在范围 [1, 1 0 4 10^4 104] 内
  • - 1 0 5 10^5 105 <= Node.val <= 1 0 5 10^5 105

算法思想：

  1. 递归法：
    （1）利用python 内置defaultdict
    defaultdict：key是node.value；value为每个value出现的次数；
    递归参数：当前二叉树节点 root
    递归结束条件：当当前数组没有元素时，说明遍历到空节点，返回即结束当前函数
    一次递归逻辑：正常中序递归
    （2）普通计数思想，双指针法
    递归参数和递归结束条件相同
    pre：中序遍历cur节点的前一个节点；cur：当前节点；
    一次递归逻辑：左递归；中序处理；右递归；其中中序处理重点说，如何表示当前是第一个节点？pre为空，cur指向第一个节点，也就是最左侧节点，此时count=1；接下来，如果pre.value = cur.value，说明cur当前指向的值与pre.value相等，count++；否则pre.value != cur.value，说明遇到了一个新的值，count=1。
  2. 迭代法：
    采用中序遍历思想，逻辑与递归法相同，采用双指针法。

代码实现：

  1. 递归法：
    （1）内置defaultdict:
# 定义树节点
from collections import defaultdict
class TreeNode:
    def __init__(self, val=0, left=None, right=None) -> None:
        self.val = val
        self.left = left
        self.rigth = right

class Solution:
    def searchBST(self, cur, freq_map):
        if cur is None:
            return 
        freq_map[cur.val] += 1
        self.searchBST(cur.left, freq_map)
        self.searchBST(cur.right, freq_map)

    def findMode(self, root):
        freq_map = defaultdict(int)
        result = []
        if root is None:
            return result
        self.searchBST(root, freq_map)
        max_freq = max(freq_map.values())
        for key, freq in freq_map.items():
            if freq == max_freq:
                result.append(key)
        return result

（2）双指针法：

# 定义树节点
class TreeNode:
    def __init__(self, val=0, left=None, right=None) -> None:
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def __init__(self) -> None:
        self.maxCount = 0
        self.count = 0
        self.pre = None
        self.result = []

    def searchBST(self, cur):
        if cur is None:
            return
        self.searchBST(cur.left)
        if self.pre is None:
            self.count += 1
        elif self.pre.val == cur.val:
            self.count += 1
        else:
            self.count = 1
        self.pre = cur
        if self.count == self.maxCount:
            self.result.append(cur.val)
        
        if self.count > self.maxCount:
            self.maxCount = self.count
            self.result = [cur.val]
        self.searchBST(cur.right)  
        return
        
    def findMode(self, root):
        self.maxCount = 0
        self.count = 0
        self.pre = None
        self.result = []

        self.searchBST(root)
        return self.result
  1. 迭代法：
# 定义树节点
class TreeNode:
    def __init__(self, val=0, left=None, right=None) -> None:
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def findMode(self, root):
        stack = []
        result = []
        pre = None
        maxCount = 0
        count = 0
        cur = root

        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                if pre is None:     # 处理第一个节点
                    count = 1
                elif cur.val == pre.val:    # 与前一个节点的值相同
                    count += 1
                else:
                    count = 1       # 与前一个节点的值不同，重新置为1
                pre = cur
                if count == maxCount:
                    result.append(cur.val)
                if count > maxCount:
                    maxCount = count
                    result = [cur.val]
                pre = cur
                cur = cur.right
        return result
一只AI学习小朋友
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题指南
weixin_70907010的博客
05-18 2240
CSDN话题挑战赛第1期 活动详情地址：https://marketing.csdn.net/p/bb5081d88a77db8d6ef45bb7b6ef3d7f 参赛话题：Leetcode刷题指南 话题描述：代码能力是一个程序员的基本能力，而除了做项目之外，大家接触到的最常规的提升代码能力的方法基本就是刷题了，因此，加油刷题，冲刺大厂！ 创作模板：Leetcode刷题指南 虽然题目是刷题指南，但实际上这是一篇面向新手的，主要讲如何比较系统地学习数据结构和算法的文章。就我个人来说，刷题（leetcod.
LeetCode刷题记录（第十五天）
qq_26424543的博客
04-04 698
Reshape the Matrix原题目：In MATLAB, there is a very useful function called 'reshape', which can reshape a matrix into a new one with different size but keep its original data.You're given a matrix repres...
关于leetcode刷题详细介绍
热门推荐
智者之家
10-01 8万+
  虽然刷题一直饱受诟病，不过不可否认刷题确实能锻炼我们的编程能力，相信每个认真刷题的人都会有体会。现在提供在线编程评测的平台有很多，比较有名的有 hihocoder，LintCode，以及这里我们关注的 LeetCode。 LeetCode收录了许多互联网公司的算法题目，被称为刷题神器，我虽然早有耳闻，不过却一直没有上面玩过。   据了解，LeetCode 是一个非常棒的 OJ（Online J...
leetcode 刷题第二十一天
m0_62627453的博客
11-12 635
solve 21
Leetcode刷题指南
mmc2015的专栏
02-13 1万+
参考：https://blog.csdn.net/qq_39521554/article/details/79160815   二、刷题方法 方法一：按照题目出现频率刷题 顺序参考文章最后的部分 方法二：标签法 按照网站给大家排列的不同tags，起到模块化的复习和学习作用。举个例子：比如复习链表的内容，就选Linked List这部分的23个题目。刷完之后可以再总结一下常用的方法和数据结...
LeetCode刷题第一天
qq_30719017的博客
04-26 117
leetcode数字变0操作次数，二进制代码解释
leetcode 刷题第十三天
m0_62627453的博客
11-04 651
solve 13
LeetCode刷题笔记 --- python
纸短情长的博客
01-21 2183
Leecode刷题笔记
Leetcode刷题打卡贴，第一次有排名啦，文末附Leetcode刷题路线
qq_53086461的博客
11-27 723
种一棵树最好的时间是十年前，其次是现在
leetcode 刷题第十一天
m0_62627453的博客
11-02 80
solve 11
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
LeetCode刷题笔记 ＃ 标题 标签 1个 两次总和 哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 ...
程序员面试宝典LeetCode刷题手册
05-18
第四章 Leetcode 题解 1. Two Sum 2. Add Two Numbers 3. Longest Substring Without Repeating Characters 4. Median of Two Sorted Arrays 7. Reverse Integer 9. Palindrome Number 11. Container With Most ...
leetcode三角形打印-algorithm:leetcode刷题记录
07-06
leetcode三角形打印 我的 LeetCode ...字符串中的第一个唯一字符(387) 大数打印 动态规划 2021/01/09 买卖股票的最佳时机 III （根据题解得出结果） 2020/10/20 最小路径和(64) 打家劫舍(198) 2020/
ACM金牌选手整理的【LeetCode刷题顺序】1
08-03
这个整理的【LeetCode刷题顺序】是由ACM金牌选手制定的，主要目的是帮助学习者系统地掌握编程算法和数据结构。LeetCode是一个在线平台，提供了各种编程挑战题目，以提升编程技能和解决实际问题的能力。 首先，我们...
javalruleetcode-leetcode:leetcode刷题笔记python代码实现
06-29
leetcode刷题笔记 （Python3\JAVA） Easy 1.两数之和() () 7.反转整数() () 9.回文数() () 14.最长公共前缀() () 20.有效的括号() () 21.合并两个有序列表() () 53.最大子序列和() () 70.爬楼梯() () 88.合并两个...
力扣Hot100-994腐烂的橘子
qq_52241267的博客
08-10 332
由于在找到腐烂水果后直接将它周围的水果置为腐烂水果，但是可能当前轮次腐烂的水果，又在当前轮次中影响周围水果，导致错误，所以可以标记：在不同轮次中被传染腐烂的水果标记为不同的数字，由于一开始time=0时，腐烂水果标记为2，所以在time=0到1这段时间被传染的水果标记为2+time+1,这样就可以使得本轮time=0时不会让标记为3的水果传染它周围的水果。左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0。
leetcode3151:特殊数组I
qq_55630615的博客
08-13 111
如果数组的每一对相邻元素都是两个奇偶性不同的数字，则该数组被认为是一个。Aging 有一个整数数组nums。如果nums是一个，返回true，否则返回false。
leetcode 103.二叉树的锯齿形层序遍历
m0_54244065的博客
08-09 880
2.做题思路:由题我们可以判断，树中每到偶数层时，就会逆置，所以我们可以采用层序遍历和逆置函数的方法来解此题。
力扣热题100_链表_206_反转链表
最新发布
weixin_42504788的博客
08-13 213
力扣热题100_链表_206_反转链表
LeetCode刷题攻略：二分法与双指针模板
"LeetCode刷题模板.pdf" 这篇文档主要涵盖了LeetCode刷题中常见的两种算法模板——二分法和双指针法，并提供了相应的代码模板、关键属性和具体题目的应用示例。以下是对这两种方法的详细解释： 1. 二分法 - 什么...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值