代码随想录算法训练营第二十一天（补）| 二叉树part07 | 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

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 __init__(self):
        self.vec = []

    def traversal(self, node):
        if not node:
            return
        
        self.traversal(node.left)
        self.vec.append(node.val)
        self.traversal(node.right)

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.vec = []
        self.traversal(root)
        if len(self.vec) < 2:
            return 0
        result = float('inf')
        for i in range(1, len(self.vec)):
            # 统计有序数组的最小差值
            result = min(result, self.vec[i] - self.vec[i - 1])
        return result

501.二叉搜索树中的众数

利用递归和字典

# 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 traversal(self, node, freq_map):
        if not node:
            return
        freq_map[node.val] += 1
        self.traversal(node.left, freq_map)
        self.traversal(node.right, freq_map)

    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        freq_map = defaultdict(int)
        result = []
        if not root:
            return result
        self.traversal(root, freq_map)
        max_freq = max(freq_map.values())
        for key, value in freq_map.items():
            if value == max_freq:
                result.append(key)
        return result

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

没太明白，再看看

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root, p, q):
        if root == q or root == p or root is None:
            return root

        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)

        if left is not None and right is not None:
            return root

        if left is None and right is not None:
            return right
        elif left is not None and right is None:
            return left
        else: 
            return None