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

102.层序遍历

思路
使用辅助结构队列进行遍历

代码

#  !/usr/bin/env  python
#  -*- coding:utf-8 -*-
# @Time   :  2022.11
# @Author :  hello algorithm!
# @Note   :  https://leetcode.cn/problems/binary-tree-level-order-traversal/
from typing import Optional, List


# 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]]:
        result = []
        queue = []
        if root:
            queue.append(root)

        while queue:
            length = len(queue)
            temp_list = []
            for i in range(length):
                node = queue.pop(0)
                temp_list.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(temp_list)
        return result


if __name__ == '__main__':
    root = TreeNode(3)
    a = TreeNode(9)
    b = TreeNode(20)
    root.left = a
    root.right = b
    b.left = TreeNode(15)
    b.right = TreeNode(7)
    s = Solution()
    print(s.levelOrder(root))

226.翻转二叉树

思路
方法1：后续遍历，交换两个孩子
方法2：前序遍历，交换两个孩子

代码

#  !/usr/bin/env  python
#  -*- coding:utf-8 -*-
# @Time   :  2022.11
# @Author :  hello algorithm!
# @Note   :  https://leetcode.cn/problems/invert-binary-tree/
# Definition for a binary tree node.
from typing import Optional


class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Solution:
    """
    方法1：后续遍历，交换两个孩子
    方法2：前序遍历，交换两个孩子
    """

    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        def traversal(cur: Optional[TreeNode]) -> None:
            if cur is None:
                return
            traversal(cur.left)
            traversal(cur.right)
            temp_node = cur.left
            cur.left = cur.right
            cur.right = temp_node

        traversal(root)
        return root


if __name__ == '__main__':
    pass

101.对称二叉树

思路
后续遍历

代码

#  !/usr/bin/env  python
#  -*- coding:utf-8 -*-
# @Time   :  2022.11
# @Author :  hello algorithm!
# @Note   :  https://leetcode.cn/problems/symmetric-tree/
# Definition for a binary tree node.
from typing import Optional


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 dfs(left_node: Optional[TreeNode], right_node: Optional[TreeNode]) -> bool:
            if left_node is None and right_node is None:
                return True
            if left_node is None and right_node:
                return False
            if left_node and right_node is None:
                return False
            if left_node.val != right_node.val:
                return False
            outer = dfs(left_node.left,right_node.right)
            inner = dfs(left_node.right,right_node.left)
            if outer and inner:
                return True
            return False
        if root is None:
            return True
        return dfs(root.left,root.right)



if __name__ == '__main__':
    pass