算法刷题打卡019 | 二叉搜索树的插入删除

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

题目链接：235. 二叉搜索树的最近公共祖先 - 力扣（Leetcode）

昨天做二叉树最近公共祖先时也一并用迭代法做完这道题，，递归法用任意一种遍历方式都可以，不再赘述。 

# 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':
        
        while root:
            if p.val < root.val and q.val < root.val:
                # 都比root小
                root = root.left
            elif p.val > root.val and q.val > root.val:
                # 都比root大
                root = root.right
            else:
                # 左右各占一个，必为最近公共祖先
                return root

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

题目链接：701. 二叉搜索树中的插入操作 - 力扣（Leetcode）

题目中，“输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同”，并且返回任意有效插入结果即可，最简单的做法是迭代查找可以插入的“空位”，从而不改变原二叉树的结构：

# 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)
        p = root
        while p:
            if p.val > val:
                if not p.left:
                    break
                else:
                    p = p.left
            else:
                if not p.right:
                    break
                else:
                    p = p.right
        # 跳出循环即为找到插入位置p
        if p.val > val:
            p.left = TreeNode(val)
        else:
            p.right = TreeNode(val)
        
        return root

跳出while循环时的p即为插入时需要用到的父节点。代码实现逻辑没有问题，就是不够精简，参考讲解用一个额外的指针记录父节点：

# 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)
        cur, parent = root, root
        while cur:
            parent = cur
            if cur.val > val:
                cur = cur.left
            else:
                cur = cur.right
        if val < parent.val:
            parent.left = TreeNode(val)
        else:
            parent.right = TreeNode(val)
        return root

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

题目链接：701. 二叉搜索树中的插入操作 - 力扣（Leetcode）

这道题考察对二叉搜索树的理解，删除目标节点后如何保证子树部分仍然符合二叉树的性质。在递归过程中，通过函数返回值完成节点的删除，当待删除的节点是叶节点直接返回空，只有一个子节点时，返回非空部分。 而当待删除节点左右非空时，以左或者右子节点作为当前子树的根都是可以的，以左子节点为根，就要将右子树插入到左子树一直向右遍历的终点，以右子节点为根则反过来，将左子树插入到右子树一直向左遍历的终点。

# 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]:
        def dfs(node):
            if not node:
                return None
            if node.val == key:
                # 进行删除操作
                if not node.left and not node.right:
                    # 删除叶节点
                    return None
                elif not node.left:
                    return node.right
                elif not node.right:
                    return node.left
                else:
                    # 以当前节点的左子树作为根返回，当前节点的右子树放到左子树最右边
                    temp = node.right
                    cur = node.left
                    while cur.right:
                        cur = cur.right
                    cur.right = temp
                    return node.left
            elif node.val < key:
                node.right = dfs(node.right)
            else:
                node.left = dfs(node.left)
            return node
        
        root = dfs(root)
        return root