236. 二叉树的最近公共祖先 - 🔗
讲解 - 🔗
💡这道题让我对回溯开始有了真正的理解,以及如何在代码里体现“左右中”的概念。按照题目意思,要返回两个节点的最近公共祖先。那么在递归时,可以判断一个节点是否等于p
或者q
,如果等于则返回当前节点,否则就进入单层递归,直到root
为None
时返回None
。
递归三部曲:
1. 明确递归函数的参数和返回值
按照上述分析,参数为root
, p
, q
,返回值为节点,所以无需新创一个递归函数。
2. 明确终止条件
终止条件分为两种情况:第一,如果root
为None
,返回None
。第二,如果root == p or root == q
,则返回root
,不去走下面的单层递归的逻辑。
3. 明确单层递归内部逻辑
当走到单层递归的逻辑时,说明root
是不满足终止条件的。那么就继续用root.left
和root.right
去获取左右子树的结果,然后根据左右子树的结果来返回根节点的结果,也就是后续遍历中的左右中。在根节点(中)这一步中,分四种情况:
- 左右子树均不为空,可以想象一下,说明
p
和q
分为位于root
的左右子树中,则root
就是p
和q
的最近公共祖先。 - 左子树为空。说明左子树中存在p或者q,亦或者都存在,但是右子树中没有
p
或者q
。那么就将left
返回,因为一个节点也可以是它自己的祖先。 - 右子树为空,同理,返回
right
。 - 左右子树都为空,说明
p
和q
都不在左右子树中,返回None
。
具体的逻辑可以参照下图。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
# 终止条件
if not root:
return None
if root == p or root == q:
return root
# 单层递归
left = self.lowestCommonAncestor(root.left, p, q) # 左
right = self.lowestCommonAncestor(root.right, p, q) # 右
# 中 - 回溯
if left != None and right != None:
return root
elif left == None and right != None:
return right
elif left != None and right == None:
return left
else: # left == None and right == None:
return None
235. 二叉搜索树的最近公共祖先 - 🔗
讲解 - 🔗
💡这道题在236. 二叉树的最近公共祖先的基础上将普通二叉树改为二叉搜索树,因此可以通过比较大小事交流流程更加高效。
class Solution:
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
if not root:
return None
if root == p or root == q:
return root
if root.val > p.val and root.val > q.val:
left = self.lowestCommonAncestor(root.left, p, q)
return left if left else None
elif root.val < p.val and root.val < q.val:
right = self.lowestCommonAncestor(root.right, p, q)
return right if right else None
else:
return root
701.二叉搜索树中的插入操作 - [🔗]https://leetcode.cn/problems/insert-into-a-binary-search-tree/description/)
讲解 - 🔗
💡这道题不难,因为可以通过距举例发现发现,无论val
是什么值,我们都可以在二叉搜索树的叶子节点插入val
,这是基于二叉搜索树的特性。
递归三部曲:
1. 明确递归函数的参数和返回值
参数为root
和val
,返回值为节点
2. 明确终止条件
可以通过比较大小,直到来到我们需要加入val
叶子节点,然后根据val
的大小,将val
插入到叶子节点的left(root.val > val
)或者right(root.val < val
)。因此终止条件为当前节点为空节点,因为我们传入叶子节点root
的左节点或者右节点一定为空。
3. 明确单层递归内部逻辑
进入单层递归,说明root
不为空,那么就按常规逻辑,去比较root.val
与val
,从而判断是向左递归还是向右递归,直到找到盖被插入val
值的叶子节点,并返回root
。
# 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 insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
# 终止条件:root为空时
if not root:
root = TreeNode(val)
return root
if root.val > val:
root.left = self.insertIntoBST(root.left, val)
else: # root.val < val:
root.right = self.insertIntoBST(root.right, val)
return root
450.删除二叉搜索树中的节点 - 🔗
讲解 - 🔗
方法一:
💡自己写了很久,但是卡住了,还是看了视频讲解。
有以下五种情况:
第一种情况:没找到删除的节点,遍历到空节点直接返回了
找到删除的节点:
第二种情况:左右孩子都为空(叶子节点),直接删除节点, 返回NULL为根节点
第三种情况:删除节点的左孩子为空,右孩子不为空,删除节点,右孩子补位,返回右孩子为根节点
第四种情况:删除节点的右孩子为空,左孩子不为空,删除节点,左孩子补位,返回左孩子为根节点
第五种情况:左右孩子节点都不为空,则将删除节点的左子树头结点(左孩子)放到删除节点的右子树的最左面节点的左孩子上,返回删除节点右孩子为新的根节点。
class Solution:
def deleteNode(self, root, key):
if root is None: # 如果根节点为空,直接返回
return root
if root.val == key: # 找到要删除的节点
if root.right is None: # 如果右子树为空,直接返回左子树作为新的根节点
return root.left
cur = root.right
while cur.left: # 找到右子树中的最左节点
cur = cur.left
root.val, cur.val = cur.val, root.val # 将要删除的节点值与最左节点值交换
root.left = self.deleteNode(root.left, key) # 在左子树中递归删除目标节点
root.right = self.deleteNode(root.right, key) # 在右子树中递归删除目标节点
return root
方法二:
💡后面看了解析,再把自己的思路改进了一下,思路如下:
- 如果根节点为空,则返回
None
。 - 如果根节点不为空,就开始进行判断,分三种情况:
root.val > key
,根湖二叉搜索树的特性,key应该往root
的左边走,因此遍历root.left
root.val < key
,key往root
的右边走,遍历root.right
- 直到遍历遇到
root.val == key
,用self.tmp
记录root的左节点。受解析的启发,只需要找到根节点的右子树中的数值最小的节点,再将root的左节点self.tmp
移到数值最小节点的左节点,即可实现重构二叉树。
因此需要判断,root.right
是否为空,如果为空,直接让root = root.left
就能实现删除root节点。如果不为空,则用self.getNewRightRoot()
去获取右子树的数值最小节点,将root的左节点self.tmp
移到数值最小节点的左节点。后来发现这一步可以不需要创建一个递归函数,直接用while循环也可以实现。也就是将self.getNewRightRoot(root.right)
替换为
做完转移这一步之后还需要删除root节点,就将cur = root.right while cur.left: cur = cur.left cur.left = self.tmp
root = root.right
即可。
class Solution:
def getNewRightRoot(self, root) -> TreeNode:
# 找右子树中最左的叶子节点
# 如果左节点为空
if not root.left:
root.left = self.tmp
return root
root.left = self.getNewRightRoot(root.left)
return root
def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
if not root:
return None
if root.val > key:
root.left = self.deleteNode(root.left, key)
elif root.val < key:
root.right = self.deleteNode(root.right, key)
else: # root.val == key
# 找左子树中最大的节点或者右子树中数值最小的节点
self.tmp = root.left
if root.right:
self.getNewRightRoot(root.right)
root = root.right
else:
root = root.left
return root