打卡第十八天

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

中序遍历会按照升序输出二叉搜索树的节点值。

class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        result = []

        def dfs(node):
            if not node:
                return None

            dfs(node.left)
            result.append(node.val)
            dfs(node.right)

        dfs(root)
        min_diff = float('inf')
        for i in range(1, len(result)):
            min_diff = min(min_diff, abs(result[i] - result[i-1])) 
        return min_diff

最优解：只用两个变量prev和min_diff，不需要存储所有节点值，直接在中序遍历过程中实时计算相邻节点差值，保证了时间复杂度和空间复杂度的最优。

def minDiffInBST(root):
    prev = None
    min_diff = float('inf')

    def in_order(node):
        nonlocal prev, min_diff
        if not node:
            return
        # 递归左子树
        in_order(node.left)
        
        if prev is not None:
            min_diff = min(min_diff, node.val - prev)
        
        prev = node.val
        # 递归右子树
        in_order(node.right)

    # 开始中序遍历
    in_order(root)
    return min_diff

501. 二叉搜索树中的众数

注意：pre == 0, if pre 返回的False。

class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return

        result = []
        max_count = 0
        cur_count = 0
        pre = None

        def dfs(node):
            nonlocal pre, max_count, cur_count, result
            if not node:
                return None

            dfs(node.left)

            if pre is not None and node.val == pre:
                cur_count += 1
            else:
                cur_count = 1

            if max_count < cur_count:
                    max_count = cur_count
                    result = [node.val]
            elif max_count == cur_count:
                result.append(node.val)

            pre = node.val

            dfs(node.right)

        dfs(root)

        return result

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

递归思路

1. 终止条件

• 如果当前节点为None，直接返回None。
• 如果当前节点是p或q，返回当前节点（因为自己就是目标节点）。

2. 递归搜索左右子树

• 对当前节点的左右子树分别递归调用。
• 左子树返回的结果是left。
• 右子树返回的结果是right。

3. 判断当前节点是否是最近公共祖先

• 如果left和right都不为空，说明p和q分别在当前节点的两侧，此时当前节点就是最近公共祖先。
• 如果只有一侧非空，说明p和q 都在该侧，返回该非空节点。

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        def dfs(node):
            if not node:
                return

            if node == p or node == q:
                return node

            left = dfs(node.left)
            right = dfs(node.right)

            if left and right:
                return node

            return left if left else right

        return dfs(root)