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

题目链接

讲解链接

思路：利用二叉搜索树的性质，其中序遍历序列是一个有序数组。所以先对二叉搜索树进行中序遍历，得到一个递增的数组后，再遍历整个数组，依次求相邻值的差，最后返回最小的差值即可。

class Solution:
    def __init__(self):
        self.vec = []
    def traversal(self, root):  # 递归中序遍历
        if not root:
            return
        self.traversal(root.left)
        self.vec.append(root.val)
        self.traversal(root.right)
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        sub = []  # 保存所有差值的数组
        self.traversal(root)
        for i in range(1, len(self.vec)):
            sub.append(abs(self.vec[i] - self.vec[i - 1]))
        return min(sub)  # 返回数组中的最小值
            

采用双指针法可以省去开辟数组的过程，需要用一个pre节点记录一下cur节点的前一个节点。

class Solution:
    def __init__(self):
        self.result = 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.result = min(self.result, cur.val - self.pre.val)  # 第一个节点不进行比较
        self.pre = cur  # 让pre指向cur
        self.traversal(cur.right)  # 右

    def getMinimumDifference(self, root):
        self.traversal(root)
        return self.result

501.二叉搜索树中的众数

题目链接

讲解链接

首先想到的是用一个字典来保存树中所有的值及其出现的次数，实现map映射。将出现次数最多的元素统计出来并保存到列表中。

class Solution:
    def __init__(self):
        self.dic = dict()  # 创建字典
    def traversal(self, root):  # 递归遍历
        if not root:
            return None
        self.traversal(root.left)
        if root:
            self.dic[root.val] = self.dic.get(root.val, 0) + 1  # 记录树中所有元素及出现的次数
        self.traversal(root.right)
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        result= []  # 定义列表保存结果
        self.traversal(root)  # 遍历树
        max_val = max(self.dic.values())  # 求字典中最大值
        for key, value in self.dic.items():  # 找到字典中最大值所对应的所有key，即为出现频次最高的元素
            if value == max_val:
                result.append(key)  # 将结果添加至列表中
        return result

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

题目链接

讲解链接

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

重点：节点本身也可以算作是公共祖先。

递归三部曲：
1.递归函数参数及返回值：参数为根节点和要查找的p，q节点，返回值为TreeNode。

def lowestCommonAncestor(self, root, p, q)

2.递归终止条件：遇到空则返回空；找到root == q，或者root == p，说明找到 q p ，则将其返回 。

if root == p or root == q or not root:
    return root

3.单层递归逻辑：本题需要遍历整棵树，先用left和right接住左子树和右子树的返回值。如果left 和 right都不为空，说明此时root就是最近公共节点。如果left为空，right不为空，就返回right，说明目标节点是通过right返回的。

left = self.lowestCommonAncestor(root.left, p, q)
right = self.owestCommonAncestor(root.right, p, q)
if not left and right:
    return right
elif left and not right:
    return left
else:
    return None

整体的查找流程如图：

完整代码如下：

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root == q or root == p or not root:  # p或q本身为公共祖先也考虑到了
            return root
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)
        if left and right:
            return root
        if not left and right:
            return right
        elif left and not right:
            return left
        else: 
            return None