算法训练记录day22

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

思路https://programmercarl.com/0235.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E7%9A%84%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88.html

题目https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
# 每次递归都判断一下条件，让root移动，直到返回p，q中间值.这样使得不论p,q谁大也无所谓
class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        
        if root.val > p.val and root.val > q.val :      # root 大于p,q 说明公共祖先在root的左边
            return self.lowestCommonAncestor(root.left,p,q)
            
        if root.val < p.val and root.val < q.val :      # root 小于p,q 说明公共祖先在root的右边
            return self.lowestCommonAncestor(root.right,p,q)
            
        return root

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

思路https://programmercarl.com/0701.%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%9A%84%E6%8F%92%E5%85%A5%E6%93%8D%E4%BD%9C.html

题目https://leetcode.cn/problems/insert-into-a-binary-search-tree/

# 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]:
        if not root:        # 节点为空，终止条件。构造新节点
            return TreeNode(val)
        if root.val > val:# 需要向左递归
            root.left = self.insertIntoBST(root.left,val) # 从这个递归出发的，用root.left 指向新节点
        if root.val < val: #需要向右递归
            root.right = self.insertIntoBST(root.right,val)
# 必须用root.left  和 root.right 接住。这样是为了让当前节点的左（右）节点指向新节点
        return root

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

思路https://programmercarl.com/0450.%E5%88%A0%E9%99%A4%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9.html

题目https://leetcode.cn/problems/delete-node-in-a-bst/

# 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 deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        if not root :  # 遇到空节点 直接返回
            return None
        if root.val > key:  # 如果节点大于key 向左递归
            root.left = self.deleteNode(root.left,key)  # 节点的左孩子 接受 符合条件（key）的节点
        elif root.val < key:    # 如果节点小于key 向右递归
            root.right = self.deleteNode(root.right,key)  # 节点的右孩子 接受 符合条件（key）的节点
        else :   # root.val == key  找到了节点
            if not root.left:    # 节点的左孩子为空 直接返回节点的右孩子
            # 返回后 就是 上一个父节点的左节点（本来是当前节点）为当前节点的右孩子，跳过了当前节点
                return root.right
            if not root.right:  # 节点的右孩子为空 直接返回节点的左孩子
                return root.left
            if not root.left and not root.right:# 左右孩子都为空 返回None 
                return None  # 即 root.left = None
            if root.left and root.right: # 左右孩子都不为空
            # 第一种处理方式 让右孩子附着到左孩子的最右叶子节点后面
                node = root.left        # 找到 左孩子
                while node.right: # 找左孩子的右节点，直到叶子节点 
                    node = node.right
                node.right = root.right # 让叶子节点的右节点等于右孩子（root.right）
                root = root.left # 让此层的节点 等于 左孩子  相当于删除了key
                # 第二种处理方式
                # node = root.right
                # while node.left:
                #     node = node.left
                # node.left = root.left
                # return root.right
                #root = root.right
        return root