算法训练营第十二天 | 二叉树（二）

---

一、Leetcode 226.反转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

参考文档：

原文链接：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目链接：https://leetcode.cn/problems/invert-binary-tree/description/
视频讲解：https://www.bilibili.com/video/BV1sP4y1f7q7/

听说Homebrew的作者Max Howell，就是因为没写出翻转二叉树，最后被Google拒绝了。（真假不做判断，全当一个乐子哈）。

在二叉树中，有深度优先搜索和广度优先搜索两大种类的遍历方式，我们首先需要考虑的就是使用哪一种遍历方式，这个很重要。

从题目描述来看，需要将每个结点的左右子节点进行交换，实际上本题使用哪种遍历方式都可以，这里使用深度优先遍历，比较容易理解。

简单的实现一个前序遍历，在访问结点的时候，执行 node.left, node.right = node.right, node.left 交换操作即可，后序遍历无非就是交换操作的顺序改变一下。

但是，使用中序遍历实现的时候，就需要稍微改动一下了，因为有的结点会被重复翻转两次。

前序or后序代码：

# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]: 
        self.helper(root)
        return root

    前序遍历
    def helper(self, root):
        if not root:
            return 
        root.left, root.right = root.right, root.left
        if root.left:
            self.helper(root.left)
        if root.right:
            self.helper(root.right)

    # 后序遍历
    # def helper(self, root):
    #     if not root:
    #         return 

    #     if root.left:
    #         self.helper(root.left)
    #     if root.right:
    #         self.helper(root.right)
    #     root.left, root.right = root.right, root.left

中序遍历代码：

# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]: 
        self.helper(root)
        return root

    中序遍历
    def helper(self, root):
        if not root:
            return 
        if root.left:
            self.helper(root.left)
        root.left, root.right = root.right, root.left
        if root.left:
            self.helper(root.left)
        

二、Leetcode 101.对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例：

输入：root = [1,2,2,3,4,4,3]
输出：true

参考文档：

原文链接：https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目链接：https://leetcode.cn/problems/symmetric-tree/description/
视频讲解：https://www.bilibili.com/video/BV1ue4y1Y7Mf/

首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！

比较的是内侧结点和外侧结点是否相同。

我们使用后序遍历法（这里其实严格来讲不是后序，但是中间结点的操作在最后完成，所以理解为后序遍历），逐层返回两个结点是否对称。

在 compare 函数中，我们获得到两个结点，对两个结点进行判断。

• 如果其中一个结点为空，直接返回 False。
• 如果两个结点都为空，直接返回 True。
• 如果两个结点都不为空，但是值不相同，返回 False。
• 如果两个结点都不为空且值相等，说明这两个对应的结点满足对称性要求，那么我们就递归遍历。

递归遍历的逻辑为，继续对左结点的左子节点和右子节点的右节点进行判断（外侧），对左节点的右子节点和右节点的左子节点进行判断（内侧）。判断完成后，将结果(bool类型)逐层返回。

代码：

# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:
        return self.compare(root.left, root.right)

    def compare(self, left, right):
        if left is None and right:
            return False
        elif left and right is None:
            return False
        elif left and right and left.val != right.val:
            return False
        elif left is None and right is None:
            return True
        
        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        return outside and inside

三、Leetcode 104.二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例：

输入：root = [3,9,20,null,null,15,7]
输出：3

参考文档：

原文链接：https://programmercarl.com/0104.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/
视频讲解：https://www.bilibili.com/video/BV1Gd4y1V75u/

理解两个概念：

• 树的深度，根结点到该结点的距离
• 树的高度，该结点到叶子结点的距离

求树的最大深度，实际上也是求得树的最大高度，使用后序遍历，不断将左右结点获得到的最大高度返回即可。

代码：

# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
        return self.getHeight(root)

    def getHeight(self, root):
        if not root:
            return 0
        leftheight = self.getHeight(root.left)
        rightheight = self.getHeight(root.right)
        height = 1 + max(leftheight, rightheight)
        return height

四、Leetcode 111.二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

示例：

输入：root = [3,9,20,null,null,15,7]
输出：2

参考文档：

原文链接：https://programmercarl.com/0111.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%B0%8F%E6%B7%B1%E5%BA%A6.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目链接：https://leetcode.cn/problems/minimum-depth-of-binary-tree/description/
视频讲解：https://www.bilibili.com/video/BV1QD4y1B7e2/?vd_source=1033b0cab567f039962e63cdd4eb3dd5

其实和求最大深度类似，不断地将最小深度返回即可。
但是需要注意的是：最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
所以需要判断：

• 某个子节点为空时，只返回不为空结点的那个高度
• 左右子节点都不为空时，返回最小高度。

代码：

# 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 minDepth(self, root: Optional[TreeNode]) -> int:
        return self.getHeight(root)

    def getHeight(self, root):
        if not root:
            return 0
        leftheight = self.getHeight(root.left)
        rightheight = self.getHeight(root.right)
        if root.left == None and root.right != None:
            return rightheight + 1
        if root.left != None and root.right == None:
            return leftheight + 1
        return min(leftheight, rightheight) + 1