算法学习9—二叉树，递归

南徐炼丹大师

已于 2023-05-30 09:04:01 修改

阅读量55

点赞数

分类专栏：算法学习文章标签：学习

于 2023-04-28 10:05:14 首次发布

本文链接：https://blog.csdn.net/weixin_45699456/article/details/130420304

版权

算法学习专栏收录该内容

27 篇文章 3 订阅

订阅专栏

计算机是怎么执行递归的？二叉树的最大深度【基础算法精讲 09】_哔哩哔哩_bilibili

104. 二叉树的最大深度

方法一：不使用全局变量

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root is None: return 0
        l_depth = self.maxDepth(root.left)
        r_depth = self.maxDepth(root.right)
        return max(l_depth, r_depth) + 1

方法二：使用全局变量

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        ans = 0
        def dfs(node, cnt):
            if node is None:
                return
            cnt += 1
            nonlocal ans
            ans = max(ans, cnt)
            dfs(node.left, cnt)
            dfs(node.right, cnt)
        dfs(root, 0)
        return ans

"nonlocal" 是 Python 中的一个关键字，用于在函数中声明一个变量不是局部变量而是外部嵌套作用域中的变量。这样在函数内部可以修改该变量的值，并且这个修改会影响到外部的嵌套作用域中该变量的值。因此，"nonlocal ans" 表示声明 "ans" 不是当前函数的局部变量，而是在函数外部的嵌套作用域中的变量。

1026. 节点与其祖先之间的最大差值

class Solution:
    def maxAncestorDiff(self, root: Optional[TreeNode]) -> int:
        ans = 0
        def dfs(node: Optional[TreeNode], mn: int, mx: int) -> None:
            if node is None: return
            # 虽然题目要求「不同节点」，但是相同节点的差值为 0，不会影响最大差值
            # 所以先更新 mn 和 mx，再计算差值也是可以的
            # 在这种情况下，一定满足 mn <= node.val <= mx
            mn = min(mn, node.val)
            mx = max(mx, node.val)
            nonlocal ans
            ans = max(ans, node.val - mn, mx - node.val)
            dfs(node.left, mn, mx)
            dfs(node.right, mn, mx)
        dfs(root, root.val, root.val)
        return ans

class Solution:
    def maxAncestorDiff(self, root: Optional[TreeNode]) -> int:
        ans = 0
        def dfs(node: Optional[TreeNode]) -> (int, int):
            if node is None:
                return inf, -inf  # 保证空节点不影响 mn 和 mx
            mn = mx = node.val
            l_mn, l_mx = dfs(node.left)
            r_mn, r_mx = dfs(node.right)
            mn = min(mn, l_mn, r_mn)
            mx = max(mx, l_mx, r_mx)
            nonlocal ans
            ans = max(ans, node.val - mn, mx - node.val)
            return mn, mx
        dfs(root)
        return ans