代码随想录算法训练营day23 | 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

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

求二叉搜索树中任意两不同节点值之间的最小差值。二叉搜索树在中序遍历时是一个递增的序列，最小差值肯定产生于两个相邻节点之间的差值

class Solution:
    def __init__(self):
        self.pre = None
        self.result = None

    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        self.traversal(root)
        return self.result

    def traversal(self, node):
        if not node:
            return
        self.traversal(node.left)
        if self.result is not None:
            self.result = min(self.result, node.val - self.pre)
        if self.pre is not None and self.result is None:
            self.result = node.val - self.pre
        self.pre = node.val
        self.traversal(node.right)   

result可以初始化为最大值，简化程序判断

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  # 记录前一个
        self.traversal(cur.right)  # 右

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

501.二叉搜索树中的众数

使用字典存储

遍历二叉搜索树，统计所有数的频率，存储在字典中，找到字典中频率最高的数字

class Solution:
    def __init__(self):
        self.result = dict()

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

    def traversal(self, node):
        if not node:
            return
        self.traversal(node.left)
        self.result[node.val] = self.result.get(node.val, 0) + 1
        self.traversal(node.right)

二叉搜索树中序遍历，遍历过程中计算数值出现的频率，与最大频率进行比较，如果等于最大频率则加入结果集中，如果大于最大频率则更新最大频率同时重置结果集

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

    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        self.traversal(root)
        return self.result

    def traversal(self, node):
        if not node:
            return
        self.traversal(node.left)
        if self.pre is None:
            self.count = 1
        elif self.pre == node.val:
            self.count += 1
        else:
            self.count = 1
        self.pre = node.val
        if self.max_count == self.count:
            self.result.append(node.val)
        if self.max_count < self.count:
            self.max_count = self.count
            self.result = [node.val]
        self.traversal(node.right)

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

二叉树的最近公共祖先，看题解前毫无思路

遇到这个题目首先想的是要是能自底向上查找就好了，这样就可以找到公共祖先了。

那么二叉树如何可以自底向上查找呢？二叉树回溯的过程就是从低到上。

后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if root == p or root == q or root is None:
            return root
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)
        if left is None and right:
            return right
        elif left and right is None:
            return left
        elif left and right:
            return root
        else:
            return None