一、学习视频
如何灵活运用递归？【基础算法精讲 10】_哔哩哔哩_bilibili
二、跟练代码
1. 100. 相同的树
递归
# 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 isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
# 递归
if p is None and q is None:
return True
elif p is None or q is None:
return False
left = self.isSameTree(p.left,q.left)
right = self.isSameTree(p.right,q.right)
return left and right and p.val == q.val学习一下灵神的写法，来自视频。
# 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 isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
# 递归
# if p is None and q is None:
# return True
# elif p is None or q is None:
# return False
if p is None or q is None:
return p is q
left = self.isSameTree(p.left,q.left)
right = self.isSameTree(p.right,q.right)
return left and right and p.val == q.val递归
# 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 f(left: Optional[TreeNode], right: Optional[TreeNode]) -> bool:
if left is None or right is None:
return left is right
return f(left.left,right.right) and f(left.right,right.left) and left.val == right.val
# #根节点为空时是满足的，此处含根节点可以省去
# if root is None:
# return True
return f(root.left,root.right)递归。不会，来自视频代码。
# 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:
# 递归
# 计算高度，非负数
# 用-1表示不是平衡二叉树
def f(node) -> int:
if node is None:
return 0
# left_h = f(node.left)
# right_h = f(node.right)
# if left_h == -1 or right_h == -1 or abs(left_h - right_h) > 1:
# return -1
# return max(left_h, right_h) + 1
# 少递归一些
left_h = f(node.left)
if left_h == -1:
return -1
right_h = f(node.right)
if right_h == -1 or abs(left_h - right_h) > 1:
return -1
return max(left_h, right_h) + 1
return f(root) != -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 rightSideView(self, root: Optional[TreeNode]) -> List[int]:
# 递归
# 先右后左遍历，当高度大于minHeight时，才会露出来
ans = []
minHeight = 0
def f(node,height):
nonlocal minHeight
if node is None:
return
if height > minHeight:
ans.append(node.val)
minHeight += 1
right = f(node.right,height + 1)
left = f(node.left,height + 1)
return
f(root,1)
return ans三、课后作业
递归
# 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 root is None:
return None
left = self.invertTree(root.left) #左子树
right = self.invertTree(root.right) #右子树
root.left = right #左右互换
root.right = left
return root不会，全都来自灵神题解（. - 力扣（LeetCode）），学习学习。
（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 maxAncestorDiff(self, root: Optional[TreeNode]) -> int:
# 递
v = -1
def f(node,mx,mn):
nonlocal v
if node is None:
return #不一定要有返回值
mx = max(mx,node.val)
mn = min(mn,node.val)
v = max(v, node.val - mn, mx - node.val) #更新
f(node.left,mx,mn)
f(node.right,mx,mn)
f(root, root.val, root.val) #根节点存在
return v（2）递的优化
# 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 maxAncestorDiff(self, root: Optional[TreeNode]) -> int:
# 递的优化
v = -1
def f(node,mx,mn):
if node is None:
nonlocal v
v = max(v, mx - mn) #到终点更新
return
mx = max(mx,node.val)
mn = min(mn,node.val)
f(node.left,mx,mn)
f(node.right,mx,mn)
f(root, root.val, root.val) #根节点存在
return v（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 maxAncestorDiff(self, root: Optional[TreeNode]) -> int:
# 归
v = -1
def f(node):
if node is None:
return inf, -inf # min max
mn = mx = node.val
lmin, lmax = f(node.left)
rmin, rmax = f(node.right)
mn = min(mn, lmin, rmin)
mx = max(mx, lmax, rmax)
nonlocal v
# 每一次都更新v
v = max(v, node.val - mn, mx - node.val)
return mn, mx
f(root)
return v递可以不用每次都更新v值，因为从上到下能确保最大小值就是该条路径的，而没有受其他路径影响；而归每次都需更新v值，一个节点有左右两边两条路径到达。
（未完待续）
感谢你看到这里！一起加油吧！
