当前位置： 首页 > ops >正文

算法训练营day18 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

ops 2025/7/15 20:27:08

        二叉树的第六篇博客！本篇博客有很多二叉搜索树的题目，在这篇博客中，你会感觉到根据二叉树的性质、题目背景不同，适用的遍历方式也存在不同，遍历方式很重要

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

        二叉搜索树采用中序遍历是一个有序数组。最直观的想法是：在一个有序数组（二叉搜索树转换）上求两个数最小差值，然后遍历数组，统计最小差值。遇到在二叉搜索树上求什么最值，求差值之类的，都要思考一下二叉搜索树可是有序的，要利用好这一特点。

递归（利用中序递增，结合数组）

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:def getMinimumDifference(self, root: Optional[TreeNode]) -> int:self.vec = []self.traversal(root)if len(self.vec) < 2:return 0result = float('inf')for i in range(1,len(self.vec)):result = min(result, self.vec[i] - self.vec[i - 1])return resultdef traversal(self, root):if root is None:return self.traversal(root.left)self.vec.append(root.val)self.traversal(root.right)

递归法（记录前节点指针,同时计算）

        要学会在递归遍历的过程中记录前后两个指针，这也是一个小技巧

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:def getMinimumDifference(self, root: Optional[TreeNode]) -> int:self.result = float('inf')self.pre = Noneself.traversal(root)return self.resultdef traversal(self, cur):if cur is None:returnself.traversal(cur.left)# 严格中序遍历顺序if self.pre is not None:self.result = min(self.result, cur.val - self.pre.val)self.pre = curself.traversal(cur.right)

迭代法

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:def getMinimumDifference(self, root: Optional[TreeNode]) -> int:stack = []cur = rootpre = Noneresult = float('inf')while cur is not None or len(stack) > 0:if cur is not None:stack.append(cur)cur = cur.left # 左else:cur = stack.pop()if pre is not None: # 中result = min(result, cur.val - pre.val)pre = curcur = cur.right # 右return  result

501.二叉搜索树中的众数

        如果不是二叉搜索树：最直观的方法是把这个树进行遍历，用map统计频率，把频率排个序，最后取前面高频的元素的集合。

        如果是二叉搜索树：它中序遍历是有序的。频率count 等于 maxCount（最大频率），将元素加入到结果集中。频率count 大于 maxCount的时候，不仅要更新maxCount，而且要清空结果集（以下代码为result数组），因为结果集之前的元素都失效了。要不然就要遍历两次二叉搜索树才能把这个最高出现频率元素的集合求出来。

递归法（字典）

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
from collections import defaultdict
class Solution:def findMode(self, root: Optional[TreeNode]) -> List[int]:freq_map = defaultdict(int)# 创建一个字典, 自动处理不存在的键#并将其默认值设为 0, 从而简化计数和频率统计的代码。result = []if root is None:return resultself.searchBST(root, freq_map)max_freq = max(freq_map.values()) # 获取字典中所有值的最大值# 若 freq_map = {'a': 3, 'b': 5, 'c': 2}# 则 freq_map.values() 的结果为 dict_values([3, 5, 2])。for key, freq in freq_map.items():# 同时获取字典的键（key）和对应的值（value）if freq == max_freq:result.append(key)return resultdef searchBST(self, cur, freq_map):    if cur is None:returnfreq_map[cur.val] += 1self.searchBST(cur.left, freq_map)self.searchBST(cur.right, freq_map)# 前序遍历

递归法（利用二叉搜索树性质）

        指针的巧妙使用，同时也是值的巧妙覆盖

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
from collections import defaultdict
class Solution:def __init__(self):self.maxCount = 0self.count = 0self.pre = Noneself.result = []def findMode(self, root: Optional[TreeNode]) -> List[int]:self.count = 0self.maxCount = 0self.pre = Noneself.result = []self.searchBST(root)return self.resultdef searchBST(self, cur):if cur is None:return self.searchBST(cur.left) # 左# 中if self.pre is None: # 第一个节点self.count += 1elif self.pre.val == cur.val:self.count += 1else: # 与前节点不同self.count = 1self.pre = cur # 前节点指针更新if self.count == self.maxCount:self.result.append(cur.val)if self.count > self.maxCount:self.maxCount = self.countself.result = [cur.val] # 同时清空result, 清空这一步很关键！self.searchBST(cur.right) # 右return # 注意中序遍历顺序, 很关键

迭代法

        其实和递归区别不是很大，但是很多细节的设计写出来是不容易的

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
from collections import defaultdict
class Solution:def findMode(self, root: Optional[TreeNode]) -> List[int]:st = []cur = rootpre = NonemaxCount = 0 # 最大频率count = 0result = []while cur is not None or st: if cur is not None: # 指针来访问节点，访问到最底层st.append(cur)cur = cur.left # 左else:cur = st.pop() # 中if pre is None:count = 1elif pre.val == cur.val:count += 1else:count = 1 # 数值不同if count == maxCount:result.append(cur.val)if count > maxCount:maxCount = countresult = [cur.val]pre = curcur = cur.right # 右return result

236. 二叉树的最近公共祖先

        遇到这个题目首先想的是——自底向上查找，这样就可以找到公共祖先了。那么二叉树如何可以自底向上查找呢？答案是——回溯，二叉树回溯的过程就是从底到上。后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。

        首先最容易想到的一个情况（重点理解）：如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者 左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。

        整体的模拟过程可以简单化为：节点的左右孩子来觉得节点的返回值

递归三部曲：

  • 确定递归函数返回值以及参数

        需要递归函数返回值，来告诉我们是否找到节点q或者p，那么返回值为bool类型就可以了。但我们还要返回最近公共节点，可以利用上题目中返回值是TreeNode * ，那么如果遇到p或者q，就把q或者p返回，即返回值不为空，就说明找到了q或者p。（重点理解）

  • 确定终止条件

        遇到空的话，因为树都是空了，所以返回空。如果 root == q，或者 root == p，说明找到 q、p ，则将其（root）返回，这个返回值，后面在中节点的处理过程中会用到

  • 确定单层递归逻辑

        值得注意的是 本题函数有返回值，是因为回溯的过程需要递归函数的返回值做判断（重点理解），但本题我们依然要遍历树的所有节点。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution:def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':if root == q or root == p or root is None: # 找到q or p, 或者没有找到(返回none)return rootleft = self.lowestCommonAncestor(root.left, p , q)right = self.lowestCommonAncestor(root.right, p , q)# 递归左子树：查找 p 或 q 是否存在于左子树中。# 递归右子树：查找 p 或 q 是否存在于右子树中。if left is not None and right is not None: # 左右子树均不为空：说明 p 和 q 分别位于当前节点的两侧return root # 这个判断需要好好理解！！if left is None and right is not None: # 仅左子树不为空：说明 p 和 q 都在左子树中, 相反在右子树中# 继续返回return rightelif left is not None and right is None: return leftelse:# 左右子树均为空：说明当前路径不包含 p 和 q，return None

那么我给大家归纳如下三点：

  1. 求最小公共祖先，需要从底向上遍历，那么二叉树，只能通过后序遍历（即：回溯）实现从底向上的遍历方式。

  2. 在回溯的过程中，必然要遍历整棵二叉树，即使已经找到结果了，依然要把其他节点遍历完，因为要使用递归函数的返回值（也就是代码中的left和right）做逻辑判断。

  3. 要理解如果返回值left为空，right不为空为什么要返回right，为什么可以用返回right传给上一层结果（理解本题的根本）——两个指定节点，即节点必定存在

注释：引用自《代码随想录》

http://www.xdnf.cn/news/15400.html

相关文章：

  • 迁移学习：知识复用的智能迁移引擎 | 从理论到实践的跨域赋能范式
  • 【前端:Typst】--let关键字的用法
  • 排序树与无序树：数据结构中的有序性探秘
  • 自定义类型 - 联合体与枚举（百度笔试题算法优化）
  • 理解Linux文件系统：从物理存储到统一接口
  • vue3 JavaScript 数据累加 reduce
  • 七、深度学习——RNN
  • 编程语言设计目的与侧重点全解析（主流语言深度总结）
  • 游戏框架笔记
  • 【小白量化智能体】应用5：编写通达信股票交易指标及生成QMT自动交易Python策略程序
  • 控制台打开mysql服务报错解决办法
  • 【STM32】什么在使能寄存器或外设之前必须先打开时钟？
  • 2025js——面试题(8)-http
  • YOLOv11开发流程
  • 为什么资深C++开发者大部分选vector？揭秘背后的硬核性能真相！
  • 【第一章编辑器开发基础第二节编辑器布局_3GUI元素和布局大小（3/4）】
  • SpringMVC3
  • JavaScript进阶篇——第二章 高级特性核心
  • 【笔记】chrome 无法打开特定协议或访问特定协议时卡死
  • Flink窗口处理函数
  • 0-1搭建springboot+vue的教务管理系统（核心源码）
  • Spring Boot 自带的 JavaMail 集成
  • Python在量化投资中的应用
  • 庸才的自我唤醒
  • Rust语言实战：LeetCode算法精解
  • Spring Boot 双数据源配置
  • 《解锁音频处理新姿势：探索Librosa的无限可能》
  • C++ 左值右值、左值引用右值引用、integral_constant、integral_constant的元模板使用案例
  • vue2/3生命周期使用建议
  • SpringBoot JAR 反编译替换文件