学习网址：https://datawhalechina.github.io/leetcode-notes/#/ch03/index.md
1. 0144. 二叉树的前序遍历
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def preorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
# 初始化结果列表
result = []
# 调用辅助函数进行前序遍历
self._preorder(root, result)
return result
def _preorder(self, node, result):
# 如果当前节点不为空，则执行以下操作：
if node:
# 1. 将当前节点的值添加到结果列表中
result.append(node.val)
# 2. 递归地对左子树进行前序遍历
self._preorder(node.left, result)
# 3. 递归地对右子树进行前序遍历
self._preorder(node.right, result)2. 0094. 二叉树的中序遍历
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def inorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
# 初始化结果列表
result = []
# 调用辅助函数进行中序遍历
self._inorder(root, result)
return result
def _inorder(self, node, result):
# 如果当前节点不为空，则执行以下操作：
if node:
# 1. 递归地对左子树进行中序遍历
self._inorder(node.left, result)
# 2. 将当前节点的值添加到结果列表中
result.append(node.val)
# 3. 递归地对右子树进行中序遍历
self._inorder(node.right, result)3. 0145. 二叉树的后序遍历
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def postorderTraversal(self, root):
"""
:type root: TreeNode
:rtype: List[int]
"""
# 初始化结果列表
result = []
# 调用辅助函数进行后序遍历
self._postorder(root, result)
return result
def _postorder(self, node, result):
# 如果当前节点不为空，则执行以下操作：
if node:
# 1. 递归地对左子树进行后序遍历
self._postorder(node.left, result)
# 2. 递归地对右子树进行后序遍历
self._postorder(node.right, result)
# 3. 将当前节点的值添加到结果列表中
result.append(node.val)1. 0102. 二叉树的层序遍历
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def levelOrder(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
# 如果根节点为空，则返回空列表
if not root:
return []
# 初始化结果列表和队列
result = []
queue = [root]
# 当队列不为空时，继续遍历
while queue:
# 获取当前层的节点数量
level_length = len(queue)
# 初始化当前层的节点值列表
level_nodes = []
# 遍历当前层的每个节点
for _ in range(level_length):
# 从队列中取出一个节点
node = queue.pop(0)
# 将节点的值添加到当前层的节点值列表中
level_nodes.append(node.val)
# 如果节点的左子节点不为空，则将其添加到队列中
if node.left:
queue.append(node.left)
# 如果节点的右子节点不为空，则将其添加到队列中
if node.right:
queue.append(node.right)
# 将当前层的节点值列表添加到结果列表中
result.append(level_nodes)
# 返回结果列表
return result2. 0104. 二叉树的最大深度
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def maxDepth(self, root):
"""
:type root: TreeNode
:rtype: int
"""
# 如果根节点为空，则返回0
if not root:
return 0
# 计算左子树的最大深度
left_depth = self.maxDepth(root.left)
# 计算右子树的最大深度
right_depth = self.maxDepth(root.right)
# 返回左右子树的最大深度加1（加上当前节点的深度）
return max(left_depth, right_depth) + 13. 0112. 路径总和
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def hasPathSum(self, root, targetSum):
"""
:type root: TreeNode
:type targetSum: int
:rtype: bool
"""
# 如果根节点为空，则返回False
if not root:
return False
# 如果当前节点是叶子节点且其值等于目标值，则返回True
if not root.left and not root.right and root.val == targetSum:
return True
# 否则，递归地在左子树和右子树中查找路径和
left_has_path = self.hasPathSum(root.left, targetSum - root.val)
right_has_path = self.hasPathSum(root.right, targetSum - root.val)
# 如果左子树或右子树中有路径和，则返回True
return left_has_path or right_has_path1. 0105. 从前序与中序遍历序列构造二叉树
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def buildTree(self, preorder, inorder):
"""
:type preorder: List[int]
:type inorder: List[int]
:rtype: TreeNode
"""
# 如果前序遍历序列为空，则返回None
if not preorder:
return None
# 获取根节点的值
root_val = preorder[0]
# 创建根节点
root = TreeNode(root_val)
# 在中序遍历序列中找到根节点的位置
root_index = inorder.index(root_val)
# 递归地构建左子树和右子树
root.left = self.buildTree(preorder[1:1+root_index], inorder[:root_index])
root.right = self.buildTree(preorder[1+root_index:], inorder[root_index+1:])
# 返回根节点
return root2. 0106. 从中序与后序遍历序列构造二叉树
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def buildTree(self, inorder, postorder):
"""
:type inorder: List[int]
:type postorder: List[int]
:rtype: TreeNode
"""
# 如果后序遍历序列为空，则返回None
if not postorder:
return None
# 获取根节点的值
root_val = postorder[-1]
# 创建根节点
root = TreeNode(root_val)
# 在中序遍历序列中找到根节点的位置
root_index = inorder.index(root_val)
# 递归地构建左子树和右子树
root.left = self.buildTree(inorder[:root_index], postorder[:root_index])
root.right = self.buildTree(inorder[root_index+1:], postorder[root_index:-1])
# 返回根节点
return root3. 0889. 根据前序和后序遍历构造二叉树
class TreeNode(object):
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution(object):
def constructFromPrePost(self, preorder, postorder):
"""
:type preorder: List[int]
:type postorder: List[int]
:rtype: TreeNode
"""
# 如果前序遍历序列为空，则返回None
if not preorder:
return None
# 获取根节点的值
root_val = preorder[0]
# 创建根节点
root = TreeNode(root_val)
# 如果前序遍历序列的长度大于1，说明存在子树
if len(preorder) > 1:
# 在后序遍历序列中找到左子树的根节点的值
left_val = preorder[1]
# 在后序遍历序列中找到左子树的根节点的位置
left_index = postorder.index(left_val)
# 递归地构建左子树和右子树
root.left = self.constructFromPrePost(preorder[1:left_index+2], postorder[:left_index+1])
root.right = self.constructFromPrePost(preorder[left_index+2:], postorder[left_index+1:-1])
# 返回根节点
return root-
遍历顺序：每种遍历方法（前序、中序、后序、层序）都有其特定的访问顺序。理解这些顺序对于解决问题至关重要。例如，前序遍历的顺序是“根-左-右”，中序遍历是“左-根-右”，后序遍历是“左-右-根”，而层序遍历则是逐层从左到右访问。
-
递归与迭代：许多二叉树问题可以通过递归来解决，因为递归自然地遵循了树的分支结构。然而，有些问题也可以通过迭代来解决，尤其是那些涉及到队列或栈的问题。
-
利用遍历序列重建树：如果给出了树的某种遍历序列，我们可以利用这些信息来重建原始的树结构。例如，如果我们有前序和中序遍历序列，我们可以先从前序序列中确定根节点，然后在中序序列中找到根节点的位置，从而确定左右子树的范围，并递归地重建左右子树。
-
边界条件处理：在编写递归函数时，我们需要考虑边界条件，如空节点或只有一个节点的树。正确处理这些边界条件对于避免错误和确保函数的正确性至关重要。
-
空间和时间复杂度分析：在解决问题时，我们还应该考虑算法的空间和时间复杂度。例如，递归解法通常具有较高的空间复杂度，因为它们需要额外的栈空间。在某些情况下，我们可以通过迭代或使用其他数据结构来优化这些复杂度。
-
二叉树的链表存储结构具有灵活、方便的特点。节点的最大数目只受系统最大可存储空间的限制。一般情况下，二叉树的链表存储结构比顺序存储结构更省空间（用于存储指针域的空间开销只是二叉树中节点数的线性函数），而且对于二叉树实施相关操作也很方便，因此，一般我们使用链式存储结构来存储二叉树。
-
根据二叉树的前序和中序序列，或者中序和后序序列，可以唯一确定一棵二叉树。但是，仅凭前序和后序序列无法确定一棵二叉树，因为缺少了中序序列来确定左右部分。
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
