算法练习（二叉树）
Posted 小小菜_v
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了算法练习（二叉树）相关的知识，希望对你有一定的参考价值。
描述
给你二叉树的根节点 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)
BM29 二叉树中和为某一值的路径(一)
描述
给定一个二叉树root和一个值 sum ，判断是否有从根节点到叶子节点的节点值之和等于 sum 的路径。
1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2.叶子节点是指没有子节点的节点
3.路径只能从父节点到子节点，不能从子节点到父节点
4.总节点数目为n
例如：
给出如下的二叉树，sum=22，
返回true，因为存在一条路径 25→4→11→2的节点值之和为 22
数据范围：
1.树上的节点数满足100000≤n≤10000
2.每 个节点的值都满足∣val∣≤1000
要求：空间复杂度 O(n)，时间复杂度 O(n)
进阶：空间复杂度 O(树的高度)，时间复杂度 O(n)
示例1
输入：5,4,8,1,11,#,9,#,#,2,7,22
返回值：true
示例2
输入：1,2,0
返回值：false
示例3
输入：1,2,3
返回值：true
示例4
输入：,0
返回值：false
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param root TreeNode类
# @param sum int整型
# @return bool布尔型
#
class Solution:
def hasPathSum(self , root: TreeNode, summer: int) -> bool:
# write code here
if root is None:
return False
if root.left is None and root.right is None and root.val == summer:
return True
return self.hasPathSum(root.left, summer-root.val) or self.hasPathSum(root.right,summer-root.val)
BM30 二叉搜索树与双向链表
描述
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。如下图所示
数据范围：输入二叉树的节点数 10000≤n≤1000，二叉树中每个节点的值 10000≤val≤1000
要求：空间复杂度O(1)（即在原树上操作），时间复杂度 O(n)
注意:
1.要求不能创建任何新的结点，只能调整树中结点指针的指向。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继
2.返回链表中的第一个节点的指针
3.函数返回的TreeNode，有左右指针，其实可以看成一个双向链表的数据结构
4.你不用输出双向链表，程序会根据你的返回值自动打印输出
输入描述：
二叉树的根节点
返回值描述：
双向链表的其中一个头节点。
示例1
输入：10,6,14,4,8,12,16
返回值：From left to right are:4,6,8,10,12,14,16;From right to left are:16,14,12,10,8,6,4;
说明：输入题面图中二叉树，输出的时候将双向链表的头节点返回即可。
示例2
输入：5,4,#,3,#,2,#,1
返回值：From left to right are:1,2,3,4,5;From right to left are:5,4,3,2,1;
说明：
5
/
4
/
3
/
2
/
1
树的形状如上图
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
#
#
# @param pRootOfTree TreeNode类
# @return TreeNode类
#
class Solution:
head= None
pre = None
def Convert(self , pRootOfTree: TreeNode):
# write code here
if pRootOfTree is None:
return
self.Convert(pRootOfTree.left)
if self.pre is None:
self.head = pRootOfTree
self.pre = pRootOfTree
else:
self.pre.right = pRootOfTree
pRootOfTree.left = self.pre
self.pre = pRootOfTree
self.Convert(pRootOfTree.right)
return self.head
BM31 对称的二叉树
描述
给定一棵二叉树，判断其是否是自身的镜像（即：是否对称）
例如： 下面这棵二叉树是对称的
下面这棵二叉树不对称。
数据范围：节点数满足 10000≤n≤1000，节点上的值满足1000∣val∣≤1000
要求：空间复杂度 O(n)，时间复杂度 O(n)
备注：
你可以用递归和迭代两种方法解决这个问题
示例1
输入：1,2,2,3,4,4,3
返回值：true
示例2
输入：
8,6,9,5,7,7,5
返回值：false
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param pRoot TreeNode类
# @return bool布尔型
#
class Solution:
def isSymmetrical(self, pRoot: TreeNode) -> bool:
# write code here
# 方式一
left_list = []
right_list = []
self.is_left(pRoot, left_list)
self.is_right(pRoot, right_list)
print(left_list)
print(right_list)
if left_list == right_list:
return True
return False
# 方式二
return self.recursion(pRoot, pRoot)
def recursion(self, root1: TreeNode, root2: TreeNode):
if not root1 and not root2:
return True
if not root1 or not root2 or root1.val != root2.val:
return False
return self.recursion(root1.left, root2.right) and self.recursion(root1.right, root2.left)
def is_right(self, pRoot: TreeNode, right_list):
if pRoot is None:
right_list.append(0)
return
right_list.append(pRoot.val)
self.is_right(pRoot.right, right_list)
self.is_right(pRoot.left, right_list)
def is_left(self, pRoot: TreeNode, left_list):
if pRoot is None:
left_list.append(0)
return
left_list.append(pRoot.val)
self.is_left(pRoot.left, left_list)
self.is_left(pRoot.right, left_list)
BM32 合并二叉树
描述
已知两颗二叉树，将它们合并成一颗二叉树。合并规则是：都存在的结点，就将结点值加起来，否则空的位置就由另一个树的结点来代替。例如：
两颗二叉树是:
数据范围：树上节点数量满足 0 \\le n \\le 5000≤n≤500，树上节点的值一定在32位整型范围内。
进阶：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n)
示例1
输入：1,3,2,5,2,1,3,#,4,#,7
返回值：3,4,5,5,4,#,7
说明：如题面图
示例2
输入：1,
返回值：1
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param t1 TreeNode类
# @param t2 TreeNode类
# @return TreeNode类
#
class Solution:
def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
# write code here
if t1 is None:
t1 = t2
ret以上是关于算法练习（二叉树）的主要内容，如果未能解决你的问题，请参考以下文章
Leetcode练习(Python)：链表类：第109题：有序链表转换二叉搜索树：给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。 本题中，一个高度平衡二叉树是指一个二叉树每个
⭐算法入门⭐《二叉树 - 二叉搜索树》中等06 —— LeetCode 173. 二叉搜索树迭代器
代码随想录算法训练营第17天 | ● 110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和
⭐算法入门⭐《二叉树 - 二叉搜索树》中等04 —— LeetCode 538. 把二叉搜索树转换为累加树