LeetCode 235.二叉搜索树的最近公共祖先：
思路：
二叉搜索树为有序树，因为所有节点的值都是唯一的，因此左子树的值都 < node.val，右子树的值都 > node.val。利用该特性，从根节点开始搜索，只需要遍历树的一边即可。
① 如果node.val在[p.val, q.val]（假设p.val < q.val）区间中，那么可以判断node为最近公共祖先节点。因为最近公共祖先节点有两种情况
1）p，q分别在node的左右子树中，那么node一定是p，q的最近公共祖先节点，此时p.val < node.val < q.val
2）node为p节点或q节点，此时node.val = p.val 或 node.val = q.val
②若p，q节点值均小于node.val，则p，q在node的左子树中
③ 若p，q节点值均大于node.val，则p，q在node的右子树中
"""
递归
"""
class Solution:
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
# 值较小的为self.p，较大的为self.q
ancestor = self.traversal(root, p, q)
return ancestor
def traversal(self, node, p, q):
if not node :
return node
if p.val < node.val and q.val < node.val: # 在左子树
left = self.traversal(node.left, p, q)
if left:
return left
elif p.val > node.val and q.val > node.val: # 在右子树
right = self.traversal(node.right, p, q)
if right:
return right
return node
"""
迭代
"""
class Solution:
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
if p.val < q.val: small, big = p, q
else: small, big = q, p
node = root
while node:
if small.val <= node.val <= big.val:
return node
elif big.val < node.val: # 在左子树
node = node.left
elif small.val > node.val: # 在右子树
node = node.right
else:
node = None
return node
LeetCode 701.二叉搜索树中的插入操作：
思路：
有多种插入方式，采用不改变二叉搜索树的结构，将新值插入二叉搜索树中的空结点的方式。
因为二叉搜索树为有序树，因此插入过程即，val < node.val，在左子树插入； val > node.val，在右子树插入。
需要明确的是，遍历过程的cur为待插入节点的上一个节点还是待插入的节点（cur为待插入节点的parent节点的话，插入操作在遍历过程中完成；cur为待插入节点的话，插入操作在遍历后完成）。
- cur为待插入节点的parent节点
遍历过程中插入节点需要判断是继续遍历下去还是插入节点（其中插入节点时只需要node对应插入的孩子节点为空即可，不需要为叶子节点）
"""
需要注意题目中root可能为空结点，因此需要单独处理
递归
"""
class Solution:
def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
if not root:
newNode = TreeNode(val=val)
return newNode
self.traversal(root, val)
return root
def traversal(self, node, val): # node为parent节点
if not node:
return
if node.left and val < node.val: # 继续递归插入左子树
self.traversal(node.left, val)
elif node.right and val > node.val: # 继续递归插入右子树
self.traversal(node.right, val)
else: # 插入为当前节点的左孩子or右孩子
newNode = TreeNode(val=val)
if val < node.val: node.left = newNode
else: node.right = newNode
"""
迭代
"""
class Solution:
def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
newNode = TreeNode(val=val)
cur = root
while cur:
if cur.left and val < cur.val:
cur = cur.left
elif cur.right and val > cur.val:
cur = cur.right
else:
if val < cur.val: cur.left = newNode
else: cur.right = newNode
return root
return newNode
- cur节点为待插入节点
"""
递归：使用递归的返回值来连接parent节点和新节点
cur节点为待插入节点，遇到空结点表明是新节点的位置
也可以不使用递归的返回值，增加一个参数parent记录新节点的parent节点，从而创建新节点后通过parent进行连接
"""
class Solution:
def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
if not root:
newNode = TreeNode(val=val)
return newNode
root = self.traversal(root, val)
return root
def traversal(self, node, val):
if not node:
newNode = TreeNode(val=val)
return newNode
if val < node.val: node.left = self.traversal(node.left, val) # 连接新节点
else: node.right = self.traversal(node.right, val) # 连接新节点
return node
"""
迭代
"""
class Solution:
def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
newNode = TreeNode(val=val)
if not root:
return newNode
parent, cur = None, root
while cur:
parent = cur
if val < cur.val:
cur = cur.left
else:
cur = cur.right
if val < parent.val: parent.left = newNode
else: parent.right = newNode
return root
感悟：
需要明确遍历过程中的cur节点是新节点的parent节点还是新节点的插入位置
LeetCode 450.删除二叉搜索树中的节点：
思路：
此处删除节点为让parent节点的左/右孩子指针指向继任的节点
需要分为多种情况讨论分析：
1）没找到删除的节点：不对树进行处理
2）待删除的节点为叶子节点：让parent节点的左/右孩子指针指向None
3）待删除的节点左子树不空，右子树为空：返回其左孩子节点作为继任的节点
4）待删除结点左子树为空，右子树不为空：返回其右孩子节点作为继任的节点（实际上是返回的整个右子树）
5）待删除结点的左右子树均不为空：选择左孩子/右孩子结点作为继任的节点。以右孩子节点作为继任的节点为例，那么还需要处理左子树，因为二叉搜索树为有序树，因此找到其右子树的最左侧节点（中序遍历中node节点的下一个遍历的节点），将左子树作为该节点的左子树。
怎么让parent节点的左/右孩子指针指向继任的节点：
使用递归的返回值，来进行连接
class Solution:
def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
root = self.traversal(root, key)
return root
def traversal(self, node, key):
if not node: # 没找到待删除的节点
return None
elif node.val == key: # 找到待删除的节点
if not node.left and not node.right: # 叶节点直接删除
return None
elif node.left and not node.right: # 左不空右空，返回左子树
return node.left
elif not node.left and node.right: # 左空右不为空，返回右子树
return node.right
else: # 左右均不为空
# 让右孩子节点继任node的位置，左子树安置到右子树中最左侧节点处
cur = node.right
while cur.left: # 找到右子树最左侧节点
cur = cur.left
cur.left = node.left # 安置左子树
return node.right
# 单层递归的逻辑
if key < node.val: node.left = self.traversal(node.left, key)
else: node.right = self.traversal(node.right, key)
return node
"""
迭代，需要使用parent保存parent节点，同时删除节点时需要单独处理删除结点为根结点的情况
"""
class Solution:
def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
parent = None
cur = root
while cur:
if cur.val == key:
break
elif key < cur.val:
parent = cur # 先更新parent，再更新cur
cur = cur.left
else:
parent = cur
cur = cur.right
if cur: # 找到了
if not parent: # 要删除的节点为根节点
return self.deleteOnenode(cur)
if key < parent.val: # 在左子树
parent.left = self.deleteOnenode(cur)
else: # 在右子树
parent.right = self.deleteOnenode(cur)
return root
def deleteOnenode(self, node):
if not node.left and not node.right: # 叶子节点
return None
elif node.left and not node.right: # 左不为空右为空
return node.left
elif not node.left and node.right: # 左空右不为空
return node.right
else: # 左右均不为空
cur = node.right
while cur.left:
cur = cur.left
cur.left = node.left
return node.right
感悟：
对于情况比较多比较复杂的题目，先分析清楚每种情况，再写代码。
一般二叉树的删除结点还没认真研究
学习收获：
学会了使用递归的返回值来连接parent结点和新结点。
利用二叉搜索树的性质：1）中序遍历为有序数组。2）左子树<根， 右子树>根，从而在二叉搜索树中找到目标结点。
最后删除二叉搜索树中的结点，需要分情况分析和改变树的结构
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
