写在前面

教程内容来自Datawhale
开源教程：https://github.com/datawhalechina/leetcode-notes/blob/main/docs/ch07/index.md
在线学习网站：https://www.datawhale.cn/learn/summary/67
ε=(´ο｀*)))唉感觉自己是个笨小孩儿，还在一直看题解

Day5题目

1.0112.路径总和

解答

思路：DFS深度优先搜索遍历，一直向下找到叶子节点（需要同时判断节点的左右子树同时为空），如果到叶子节点时sum==0，说明找到了一条符合要求的路径。

# 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 hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:if not root:return Falseif not root.left and not root.right:return targetSum == root.valreturn self.hasPathSum(root.left,targetSum - root.val) or self.hasPathSum(root.right,targetSum - root.val)

时间复杂度：O(n)
空间复杂度：O(1)
题解：
回溯：利用DFS找到从根节点到叶子节点的所有路径，只要有任何一条路径的和等于sum，就返回true。
（并非严格意义上的回溯法，因为没有重复利用path变量）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = Noneclass Solution(object):def hasPathSum(self, root, sum):if not root: return Falseres = []return self.dfs(root, sum, res, [root.val])def dfs(self, root, target, res, path):if not root: return Falseif sum(path) == target and not root.left and not root.right:return Trueleft_flag, right_flag = False, Falseif root.left:left_flag = self.dfs(root.left, target, res, path + [root.left.val])if root.right:right_flag = self.dfs(root.right, target, res, path + [root.right.val])return left_flag or right_flag

时间复杂度：O(n)
空间复杂度：O(1)
BFS：使用队列保存遍历到每个节点时的路径和，如果该节点恰好是叶子节点，并且路径和正好等于sum，说明找到了解。

# 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 hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:if not root:return Falseque = collections.deque()que.append((root,root.val))while que:node,path = que.popleft()if not node.left and not node.right and path == targetSum:return Trueif node.left:que.append((node.left,path + node.left.val))if node.right:que.append((node.right,path + node.right.val))return False

时间复杂度：O(n)
空间复杂度：O(n)

2.0113路径总和II

解答

题解：
典型的回溯问题，解法包含先序遍历+路径记录两部分：

• 先序遍历：按照“根、左、右”的顺序，遍历树的所有节点。
• 路径记录：在先序遍历中，记录从根节点到当前节点的路径。当路径满足 (1) 根节点到叶节点形成的路径 且 (2) 各节点值的和等于目标值 targetSum 时，将此路径加入结果列表。
  
  算法流程：
  函数pathSum（root，targetSum）：
  初始化：结果列表res，路径列表path
  返回值：返回res即可
  函数recur（root,tar）：
  递推参数：当前节点root,当前目标值tar。
  终止条件：若节点root为空，则直接返回
  递推工作：
  1.路径更新：将当前节点值root.val加入路径path
  2.目标值更新：tar = tar - root.val（即目标值tar从targetSum减至0）
  3.路径记录：当（1）root为叶节点且（2）路径和等于目标值，则将此路径path加入res
  4.先序遍历：递归左/右子节点
  5.路径恢复：向上回溯前，需要将当前节点从路径path中删除，即执行path.pop()

# 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 pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:res,path = [],[]def recur(root,tar):if not root:returnpath.append(root.val)tar -= root.valif tar == 0 and not root.left and not root.right:res.append(list(path))recur(root.left,tar)recur(root.right,tar)path.pop()recur(root,targetSum)return res

时间复杂度：O(n)
空间复杂度：O(n)

3.0101.对称二叉树

解答

题解：
对称二叉树定义： 对于树中 任意两个对称节点 L 和 R ，一定有：
L.val = R.val ：即此两对称节点值相等。
L.left.val = R.right.val ：即 L 的 左子节点 和 R 的 右子节点 对称。
L.right.val = R.left.val ：即 L 的 右子节点 和 R 的 左子节点 对称。
根据以上规律，考虑从顶至低递归，判断每对左右节点是否对称，从而判断树是否为对称二叉树。

# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:def recur(L,R):if not L and not R:return Trueif not L or not R or L.val != R.val:return Falsereturn recur(L.left,R.right) and recur(L.right,R.left)return not root or recur(root.left,root.right)

时间复杂度：O(N)
空间复杂度：O(N)

Day6题目

1.0124.二叉树中的最大路径和

解答

# 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 maxPathSum(self, root: Optional[TreeNode]) -> int:ans = -infdef dfs(node:Optional[TreeNode]) -> int:if node is None:return 0 #没有节点，和为0l_val = dfs(node.left) #左子树最大链和r_val = dfs(node.right) #右子树最大链和nonlocal ansans = max(ans,l_val + r_val + node.val) #两条链拼成路径return max(max(l_val,r_val) + node.val,0) #当前子树最大链和（注意这里和0取最大值）dfs(root)return ans

时间复杂度：O(n）
空间复杂度：O(n)

2.0199.二叉树的右视图

解答

思考：即找每一层最右边的节点，可以利用层次遍历。
流程：
1、初始化队列，先将二叉树的根结点放入队列；根据队列是否为空作为循环条件；
2、获取当前层的元素个数（队列长度），并将队列尾部的元素值添加到右视图中。
3、按照队列长度遍历队列中的元素，并将其左右孩子（如果存在）添加到队列尾部，然后将当前元素出队。
4、重复步骤2,3，直到队列为空。

# 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 rightSideView(self, root: Optional[TreeNode]) -> List[int]:if not root:return []q = deque([root])ans = []while q:nxt = deque()size = len(q)ans.append(q[-1].val)for _ in range(size):cur = q.popleft()if cur.left:nxt.append(cur.left)if cur.right:nxt.append(cur.right)q = nxtreturn ans

时间复杂度：O(n)
空间复杂度：O(n)

3.0226.翻转二叉树

解答

思考：递归
根据二叉树镜像的定义，考虑递归遍历（dfs）二叉树，交换每个节点的左 / 右子节点，即可生成二叉树的镜像。

# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:if not root:returntmp = root.leftroot.left = self.invertTree(root.right)root.right = self.invertTree(tmp)return root

时间复杂度 O(N) ： 其中 N 为二叉树的节点数量，建立二叉树镜像需要遍历树的所有节点，占用 O(N) 时间。
空间复杂度 O(N) ： 最差情况下（当二叉树退化为链表），递归时系统需使用 O(N) 大小的栈空间。

Day7题目

1.0105.从前序与中序遍历序列构造二叉树

解答

题解：
前序遍历性质：节点按照【根节点 | 左子树 | 右子树】排序
前序遍历性质：节点按照【左子树 | 根节点 | 右子树】排序
算法流程：
递推参数：根节点在前序遍历的索引root、子树在中序遍历的左边界left，子树在中序遍历的右边界right
终止条件：当left > right，代表已经越过叶节点，此时返回null
递推工作：
1、建立根节点node：节点值为preorder[root]
2、划分左右子树：查找根节点在中序遍历inorder中的索引i。
3、构建左右子树：开启左右子树递归

# 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 buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:def recur(root,left,right):if left > right:return #递归终止node = TreeNode(preorder[root]) #建立根节点i = dic[preorder[root]] #划分根节点、左子树、右子树node.left = recur(root + 1,left,i - 1) #开启左子树递归node.right = recur(i - left + root + 1,i + 1,right) #开启右子树递归return node #回溯返回根节点dic,preorder = {},preorderfor i in range(len(inorder)):dic[inorder[i]] = ireturn recur(0,0,len(inorder) - 1)

时间复杂度 O(N)
空间复杂度 O(N)

2.0098.验证二叉搜索树

解答

利用二叉搜索树的性质，即左子树的所有节点值都小于根节点值，右子树的所有节点值都大于根节点值
前序遍历：

# 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 isValidBST(self, root: Optional[TreeNode],left=-inf,right=inf) -> bool:if root is None:return Truex = root.valreturn left < x < right and self.isValidBST(root.left,left,x) and self.isValidBST(root.right,x,right)

时间复杂度 O(N)
空间复杂度 O(N)

3.0110.平衡二叉树

解答

性质：当前树的深度 等于 左子树的深度 与 右子树的深度 中的 最大值 +1。

方法一：后序遍历 + 剪枝 （从底至顶）
思路是对二叉树做后序遍历，从底至顶返回子树深度，若判定某子树不是平衡树则 “剪枝” ，直接向上返回。

# 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 isBalanced(self, root: Optional[TreeNode]) -> bool:def recur(root):if not root:return 0left = recur(root.left)if left == -1:return -1right = recur(root.right)if right == -1:return -1return max(left,right) + 1 if abs(left - right) <= 1 else -1return recur(root) != -1

时间复杂度 O(N)
空间复杂度 O(N)

Day8题目

1.0200.岛屿数量

解答

2.0695.导语的最大面积

解答

3.0129.求根节点到叶节点数字之和

解答