代码随想录算法训练营第二十二天｜236. 二叉树的最近公共祖先(补3.12)、235. 二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作、450.删除二叉搜索树中的节点

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去获取左右子树的结果，然后根据左右子树的结果来返回根节点的结果，也就是后续遍历中的左右中。在根节点（中）这一步中，分四种情况：

1. 左右子树均不为空，可以想象一下，说明p和q分为位于root的左右子树中，则root就是p和q的最近公共祖先。
2. 左子树为空。说明左子树中存在p或者q，亦或者都存在，但是右子树中没有p或者q。那么就将left返回，因为一个节点也可以是它自己的祖先。
3. 右子树为空，同理，返回right。
4. 左右子树都为空，说明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

方法二：

💡后面看了解析，再把自己的思路改进了一下，思路如下：

1. 如果根节点为空，则返回None。
2. 如果根节点不为空，就开始进行判断，分三种情况：
   • 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)替换为

     cur = root.right
     while cur.left:
        cur = cur.left
     cur.left = self.tmp
     

     做完转移这一步之后还需要删除root节点，就将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