代码随想录算法训练营第22天 |二叉搜索树的最近公共祖先 、二叉搜索树中的插入操作、删除二叉搜索树中的节点

1、二叉搜索树的最近公共祖先

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode': 
        if not root: return None # 终止条件
        
        #如果root的值比p和q都大，向左遍历
        if root.val > q.val and root.val > p.val: 
            left = self.lowestCommonAncestor(root.left, p, q)
            
            # 如果在左子树找到了公共祖先，立即返回
            if left:
                return left

        # 向右遍历一样的逻辑
        elif root.val < q.val and root.val < p.val:
            right = self.lowestCommonAncestor(root.right,p ,q)
            if right:
                return right
    
        # 找到了公共祖先，返回
        return root

2、二叉搜索树中的插入操作

class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        def traversal(node, val):
            # 终止条件：遍历到叶子节点，在叶子节点添加节点
            if not node:
                return TreeNode(val)
            
            # 如果val比node.val小，向左遍历，反之向右遍历
            if val < node.val:
                node.left = traversal(node.left, val)
            else:
                node.right = traversal(node.right, val)

            # 返回根节点
            return node
        return traversal(root, val)

3、删除二叉搜索树中的节点

class Solution:
    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        # 没有找到该节点，返回None
        if not root : return None

        # 找到该节点的情况，前序遍历
        if root.val == key:

            # 该节点是叶子节点，直接删除
            if not root.left and not root.right:
                return None

            # 该节点只有左右孩子之一，左右孩子继位
            elif root.left and not root.right:
                return root.left
            elif root.right and not root.left:
                return root.right

            # 该节点左右孩子都有
            else:
                # 找到右子树最左侧的节点，把目标节点左子树移植到最左侧节点的左子树
                cur = root.right
                while cur.left:
                    cur = cur.left
                cur.left = root.left
                # 然后右孩子继位
                return root.right
        
        # key比val小，向左遍历，反之向右
        if key < root.val:
            root.left = self.deleteNode(root.left, key)
        else:
            root.right = self.deleteNode(root.right, key)

        # 任务完成返回根节点
        return root