代码随想录算法训练营第十五天 | 二叉树层序遍历、226. 翻转二叉树、101. 对称二叉树

二叉树的层序遍历

102. 二叉树的层序遍历 - 力扣（LeetCode）

# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        res = []
        def helper(root, depth):
            if root == None:
                return
            if len(res) == depth:
                res.append([])
            res[depth].append(root.val)
            helper(root.left, depth+1)
            helper(root.right, depth+1)
        helper(root, 0)
        return res

这里主要是通过将depth作为索引，最后实现层序的输出，但实际上是深度优先

107. 二叉树的层序遍历 II - 力扣（LeetCode）

# 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 levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        res = []
        def helper(root, depth):
            if root == None:
                return
            if len(res) == depth:
                res.append([])
            res[depth].append(root.val)
            helper(root.left, depth+1)
            helper(root.right, depth+1)
        helper(root, 0)
        return res[::-1]

这边相比上题就是加了个倒序输出

其他的题目其实就是对res数组做一些操作后再输出

226. 翻转二叉树 - 力扣（LeetCode）

前序遍历代码如下：

# 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]:
        if not root:
            return None
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

后序遍历代码如下：

# 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]:
        if not root:
            return None
        self.invertTree(root.left)
        self.invertTree(root.right)
        root.left, root.right = root.right, root.left
        return root

101. 对称二叉树 - 力扣（LeetCode）

# 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:
        def compare(left, right):
            if left == None and right == None:
                return True
            elif left == None and right != None:
                return False
            elif left != None and right == None:
                return False
            elif left.val != right.val:
                return False
            else:
                return compare(left.left, right.right) and compare(left.right, right.left)
        
        if root == None:
            return True
        else:
            return compare(root.left, root.right)

这里面的各个逻辑需要想清楚再写

总结

主要学习了应用递归法结合不同的遍历顺序来进行二叉树的一些判断