二叉树练习

Posted 2022-09-07 小小菜_v

描述
给你二叉树的根节点 root ，返回它节点值的 前、中、后序遍历。
数据范围：二叉树的节点数量满足 0≤n≤100 ，二叉树节点的值满足1≤val≤100 ，树的各节点的值各不相同

BM23 二叉树的前序遍历

示例1
输入：1,#,2,3
返回值：[1,2,3]

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型一维数组
#
class Solution:
    def preorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here
        tree_list = []
        self.perorder(tree_list, root)
        return tree_list
    
    def perorder(self, tree_list: List[int], root: TreeNode):
        if root is None:
            return 
        tree_list.append(root.val)
        self.perorder(tree_list, root.left)
        self.perorder(tree_list, root.right)
            

BM24 二叉树的中序遍历

示例1
输入：1,2,#,#,3
返回值：[2,3,1]
  
示例2
输入：
返回值：[]

示例3
输入：1,2
返回值：[2,1]
 
示例4
输入：1,#,2
返回值：[1,2]

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型一维数组
#
import sys
sys.setrecursionlimit(10000)
class Solution:
    def inorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here
        tree_list = []
        self.inorder(root, tree_list)
        return tree_list
    
    def inorder(self, root: TreeNode, tree_list:List[int]):
        if root is None:
            return
        
        self.inorder(root.left, tree_list)
        tree_list.append(root.val)
        self.inorder(root.right, tree_list)

BM25 二叉树的后序遍历

示例1
输入：1,#,2,3
返回值：[3,2,1]
  
示例2
输入：1
返回值：[1]

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型一维数组
#
class Solution:
    def postorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here
        tree_list = []
        self.postorder(tree_list, root)
        return tree_list
    
    def postorder(self, tree_list:List[int], root: TreeNode):
        if root is None:
            return
        
        self.postorder(tree_list, root.left)
        self.postorder(tree_list, root.right)
        tree_list.append(root.val)

BM26 求二叉树的层序遍历

描述
给定一个二叉树，返回该二叉树层序遍历的结果，（从左到右，一层一层地遍历）
例如：
给定的二叉树是3,9,20,#,#,15,7,
该二叉树层序遍历的结果是
[
[3],
[9,20],
[15,7]
]
数据范围：二叉树的节点数满足 1≤n≤10^5

示例1
输入：1,2
返回值：[[1],[2]]

示例2
输入：1,2,3,4,#,#,5
返回值：[[1],[2,3],[4,5]]

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型二维数组
#
import sys
sys.setrecursionlimit(100000)
class Solution:
    def levelOrder(self , root: TreeNode) -> List[List[int]]:
        # write code here
        leve_list = []
        i = 0
        self.level(i, leve_list, root)
        return leve_list
    
    def level(self, i, level_list:List[int], root: TreeNode):
        """通过树的层数和列表的索引来进行递归处理"""
        if root is None:
            return
        if len(level_list)-1 >= i:
            level_list[i].append(root.val)
        else:
            level_list.append([root.val])
        i += 1
        self.level(i, level_list, root.left)
        self.level(i, level_list, root.right)

BM27 按之字形顺序打印二叉树

描述
给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替）
数据范围：0≤n≤1500,树上每个节点的val满足∣val∣<=1500
要求：空间复杂度：O(n)，时间复杂度：O(n)
例如：
给定的二叉树是1,2,3,#,#,4,5
该二叉树之字形层序遍历的结果是
[
[1],
[3,2],
[4,5]
]

示例1
输入：1,2,3,#,#,4,5
返回值：[[1],[3,2],[4,5]]
说明：如题面解释，第一层是根节点，从左到右打印结果，第二层从右到左，第三层从左到右。 
    
示例2
输入：8,6,10,5,7,9,11
返回值：[[8],[10,6],[5,7,9,11]]

示例3
输入：1,2,3,4,5
返回值：[[1],[3,2],[4,5]]

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param pRoot TreeNode类 
# @return int整型二维数组
#
import sys
sys.setrecursionlimit(100000)

class Solution:
    def Print(self , pRoot: TreeNode) -> List[List[int]]:
        # write code here
        i = 0
        l = []
        self.p(i, l, pRoot)
        return l
    
    def p(self, i, l:List[int], pRoot:TreeNode):
        
        if pRoot is None:
            return
        
        if i > len(l)-1:
            l.append([pRoot.val])
        elif i <= len(l)-1 and (i+1)%2 == 0:
#         elif (i+1)%2 == 0:
            l[i].insert(0, pRoot.val)
        else:
            l[i].append(pRoot.val)
        i += 1
        self.p(i, l, pRoot.left)
        self.p(i, l, pRoot.right) 

BM28 二叉树的最大深度

描述
求给定二叉树的最大深度，
深度是指树的根节点到任一叶子节点路径上节点的数量。
最大深度是所有叶子节点的深度的最大值。
（注：叶子节点是指没有子节点的节点。）
数据范围：0≤n≤100000，树上每个节点的val满足 ∣val∣≤100
要求： 时间复杂度 O(n)

示例1
输入：1,2
返回值：2

示例2
输入：1,2,3,4,#,#,5
返回值：3

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return int整型
#
class Solution:
    def maxDepth(self , root: TreeNode) -> int:
        # write code here
        l = []
        i = 0
        self.max_d(i, l, root)
        return len(l)
    
    def max_d(self, i, l:List[int], root: TreeNode):
        
        if root is None:
            return 
        if i > len(l)-1:
            l.append([root.val])
        else:
            l[i].append(root.val)
        i += 1
        self.max_d(i, l, root.left)
        self.max_d(i, l, root.right)