Leetcode 第七天（三） 三叉树遍历 python

144. 二叉树的前序遍历
给你二叉树的根节点 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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
            res=[]
            def dfs(node):
                nonlocal res
                if node==None:
                    return
                res.append(node.val)
                dfs(node.left)
                dfs(node.right)
            dfs(root)
            return res

145. 二叉树的后序遍历
给你一棵二叉树的根节点 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res=[]
        def dfs(node):
            nonlocal res
            if node is None:
                return 
            dfs(node.left)
            dfs(node.right)
            res.append(node.val)
        dfs(root)
        return res

94. 二叉树的中序遍历
给定一个二叉树的根节点 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res=[]
        def dfs(node):
            if node==None:
                return 
            dfs(node.left)
            res.append(node.val)
            dfs(node.right)
        dfs(root)
        return res

102. 二叉树的层序遍历
给你二叉树的根节点 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root==None:
            return []
        
        # if root.left==None and root.right==None:
        #     return [[]]
        res=[[root.val]]
        que=[]
        if root.left!=None:
            que.append(root.left)
        if root.right!=None:
            que.append(root.right)
        while len(que)!=0:
                len_=len(que)
                temp=[]
                for i in range(len_):
                    child=que.pop(0)
                    temp.append(child.val)
                    if child.left!=None:
                        que.append(child.left)
                    if child.right!=None:
                        que.append(child.right)
                res.append(temp)
        return res

107. 二叉树的层序遍历 II
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root==None:
            return []
        
        # if root.left==None and root.right==None:
        #     return [[]]
        res=[[root.val]]
        que=[]
        if root.left!=None:
            que.append(root.left)
        if root.right!=None:
            que.append(root.right)
        while len(que)!=0:
                len_=len(que)
                temp=[]
                for i in range(len_):
                    child=que.pop(0)
                    temp.append(child.val)
                    if child.left!=None:
                        que.append(child.left)
                    if child.right!=None:
                        que.append(child.right)
                res.insert(0,temp)
        return res