二叉树——701. 二叉搜索树中的插入操作、450. 删除二叉搜索树中的节点、669. 修剪二叉搜索树

二叉搜索树中的插入操作

给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。

输入：root = [4,2,7,1,3], val = 5
输出：[4,2,7,1,3,5]

# 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:TreeNode, val:int) -> TreeNode:
        insertNode = TreeNode(val)
        # 如果二叉搜索树为空
        if root == None:
            return insertNode
        # 如果根节点的左子树为空且插入的节点值比根节点值小
        if root.left == None and val < root.val:
            root.left = insertNode
        # 如果根节点的右子树为空且插入节点值比根节点值大
        if root.right == None and val > root.val:
            root.right = insertNode
        # 如果根节点的左子树不为空且插入的节点值比根节点小
        if val < root.val:
            self.insertIntoBST(root.left, val)
        # 如果根节点的右子树不为空且插入的节点值比根节点大
        if val > root.val:
            self.insertIntoBST(root.right, val)
        return root

450. 删除二叉搜索树中的节点
给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

1. 首先找到需要删除的节点；
2. 如果找到了，删除它。

输入：root = [5,3,6,2,4,null,7], key = 3
输出：[5,4,6,2,null,null,7]
解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
另一个正确答案是 [5,2,6,null,4,null,7]。

# 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 root == None:
            return root
        # 如果要删除的节点 key 比 root 小
        if root.val > key:
            # 继续在左子树寻找
            root.left = self.deleteNode(root.left, key)
        # 如果要删除的节点 key 比 root 大
        elif root.val < key:
            # 继续在右子树寻找
            root.right = self.deleteNode(root.right, key)

        # 如果找到了要删除的节点 key
        else:
            # 情况1：如果key是叶子节点，直接删除
            if root.left == None and root.right == None:
                root = None
                return root
            # 情况2：如果key只有左子树
            elif root.left != None and root.right == None:
                return root.lefe
            # 情况3：如果key只有右子树
            elif root.left == None and root.right != None:
                return root.right
            # 情况4：如果key左右子树都有，此处将 key 位置的值替换成右子树的最小值
            else:
                node = root.right
                while node.left:
                    node = node.left
                root.val = node.val
                # 删除右子树的最小值
                root.right = self.deleteNode(root.right, node.val)
        return root

669. 修剪二叉搜索树
给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。
所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。

输入：root = [1,0,2], low = 1, high = 2
输出：[1,null,2]

# 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 trimBST(self, root: Optional[TreeNode], low: int, high: int) -> Optional[TreeNode]:
        if root == None:
            return None
        # 如果当前节点的值 < 左边界  根据二叉搜索树的特性，只需要考虑右子树，抛弃左子树
        if root.val < low:
            return self.trimBST(root.right, low, high)
        # 如果当前节点值 > 右边界， 根据二叉搜索树特性，只需要考虑左子树，抛弃右子树
        if root.val > high:
            return self.trimBST(root.left, low, high)
        # root 在 [low, high] 区间内
        if low <= root.val <= high:
            root.left = self.trimBST(root.left, low, high)
            root.right = self.trimBST(root.right, low, high)
            return root