训练营一期day19

# 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:
        # 中序遍历
        res = []
        minVal = math.inf
        def buildList(root):
            if not root:
                return None 
            if root.left:
                buildList(root.left)
            res.append(root.val)
            if root.right:
                buildList(root.right)
            return res 
        buildList(root) 
        for i in range(len(res)-1):
            minVal = min(abs(res[i]-res[i+1]),minVal) 
        return minVal

# 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
class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        num_list = {}
        res = []
        def buildList(root):
            if not root:
                return None 
            res.append(root.val)
            if root.left: 
                buildList(root.left)
            if root.right:
                buildList(root.right)
            return res 
        buildList(root)
        for i in range(len(res)): 
            num_list[res[i]] = num_list.get(res[i],0) + 1
        return [key for m in [max(num_list.values())] for key,val in num_list.items() if val == m]

代码随想录的写法：

# 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.pre = TreeNode()
        self.count = 0
        self.max_count = 0
        self.result = []

    def findMode(self, root: TreeNode) -> List[int]:
        if not root: return None
        self.search_BST(root)
        return self.result
        
    def search_BST(self, cur: TreeNode) -> None:
        if not cur: return None
        self.search_BST(cur.left)
        # 第一个节点
        if not self.pre:
            self.count = 1
        # 与前一个节点数值相同
        elif self.pre.val == cur.val:
            self.count += 1 
        # 与前一个节点数值不相同
        else:
            self.count = 1
        self.pre = cur

        if self.count == self.max_count:
            self.result.append(cur.val)
        
        if self.count > self.max_count:
            self.max_count = self.count
            self.result = [cur.val]	# 清空self.result，确保result之前的的元素都失效
        
        self.search_BST(cur.right)

# 

# 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: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        # 后续遍历
        if not root or root == p or root == q:
            return root  
        left = self.lowestCommonAncestor(root.left,p,q)
        right = self.lowestCommonAncestor(root.right,p,q)

        if left and right:
            return root  
        if left:
            return left 
        return right
        

二叉树还是很难