算法训练第二十天

235. 二叉搜索树的最近公共祖先

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if root is None:
            return root
        if root==p or root==q:
            return root
        left = self.lowestCommonAncestor(root.left,p,q)
        right = self.lowestCommonAncestor(root.right,p,q)
        if left and right:
            return root
        if left and right is None:
            return left
        if left is None and right:
            return right
        

701.二叉搜索树中的插入操作

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def insertIntoBST(self, root, val):
        """
        :type root: Optional[TreeNode]
        :type val: int
        :rtype: Optional[TreeNode]
        """
        if root is None:
            new_node = TreeNode(val=val)
            return new_node
        pre = root
        if val < root.val:
            self.find(root.left,val,root)
        else:
            self.find(root.right,val,root)
        return root
    
    def find(self,node,val,pre):
        if node is None:
            new_node = TreeNode(val=val)
            if new_node.val<pre.val:
                pre.left=new_node
            else:
                pre.right=new_node
            return
        if val<node.val:
            self.find(node.left,val,node)
        else:
            self.find(node.right,val,node)

450.删除二叉搜索树中的节点

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def deleteNode(self, root, key):
        """
        :type root: Optional[TreeNode]
        :type key: int
        :rtype: 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:
            # 找到要删除的节点
            
            # 情况1：节点没有左子节点
            if not root.left:
                return root.right
            # 情况2：节点没有右子节点
            elif not root.right:
                return root.left
            # 情况3：节点有两个子节点
            else:
                # 找到右子树中的最小节点（中序后继）
                successor = self.findMin(root.right)
                # 用后继节点的值替换当前节点的值
                root.val = successor.val
                # 删除后继节点（现在它的值已经被使用）
                root.right = self.deleteNode(root.right, successor.val)
        
        return root
    
    def findMin(self, node):
        # 找到二叉搜索树中的最小节点
        while node.left:
            node = node.left
        return node