2024/5/1--代码随想录算法训练营day22|235. 二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作、450.删除二叉搜索树中的节点

西西，正在减肥

已于 2024-05-06 11:29:19 修改

阅读量217

点赞数 1

分类专栏： # 树文章标签：算法

于 2024-05-01 22:44:18 首次发布

本文链接：https://blog.csdn.net/qq_46277517/article/details/138381652

版权

树专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章详细探讨了在二叉搜索树中使用递归和迭代方法查找最近公共祖先，以及插入和删除节点的技巧，涉及递归参数、终止条件和多种情况下的代码实现。

摘要由CSDN通过智能技术生成

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

力扣链接
在这里插入图片描述

和day21的题目236二叉树的最近公共祖先，这一道题可以用二叉搜索树的特性
当我们从上向下去递归遍历，第一次遇到 cur节点是数值在[q, p]区间中，那么cur就是 q和p的最近公共祖先。

递归三步曲

递归参数和返回值：参数（root，p,q）返回值：节点
终止条件：当node为空
单层递归：在遍历二叉搜索树的时候就是寻找区间[p->val, q->val]（注意这里是左闭又闭），那么如果 cur->val 大于 p->val，同时 cur->val 大于q->val，那么就应该向左遍历（说明目标区间在左子树上）
需要注意的是此时不知道p和q谁大，所以两个都要判断

递归法
class Solution:
    def traversal(self, cur, p, q):
        if cur is None:
            return cur
                                                        # 中
        if cur.val > p.val and cur.val > q.val:           # 左
            left = self.traversal(cur.left, p, q)
            if left is not None:
                return left
        if cur.val < p.val and cur.val < q.val:           # 右
            right = self.traversal(cur.right, p, q)
            if right is not None:
                return right
        return cur   #如果在区间内，就直接返回

    def lowestCommonAncestor(self, root, p, q):
        return self.traversal(root, p, q)

递归法+精简版
class Solution:
    def lowestCommonAncestor(self, root, p, q):
        if root.val > p.val and root.val > q.val:
            return self.lowestCommonAncestor(root.left, p, q)
        elif root.val < p.val and root.val < q.val:
            return self.lowestCommonAncestor(root.right, p, q)
        else:
            return root

迭代法
class Solution:
    def lowestCommonAncestor(self, root, p, q):
        while root:
            if root.val > p.val and root.val > q.val:
                root = root.left
            elif root.val < p.val and root.val < q.val:
                root = root.right
            else:
                return root
        return None

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

力扣链接
在这里插入图片描述

递归三步曲

递归参数和返回值：递归参数（root和val）返回值 node》
终止条件：当遍历的节点为空，就是要插入的节点的位置，并把插入的节点返回。
单层遍历逻辑：【首先明确，遍历一条边还是整个树？因为搜索树，搜索树有方向，可以根据插入元素的值，决定遍历方向】

递归
class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if root is None or root.val == val:
            return TreeNode(val)
        elif root.val > val:
            if root.left is None:
                root.left = TreeNode(val)
            else:
                self.insertIntoBST(root.left, val)
        elif root.val < val:
            if root.right is None:
                root.right = TreeNode(val)
            else:
                self.insertIntoBST(root.right, val)
        return root

递归+精简版
class Solution:
    def insertIntoBST(self, root, val):
        if root is None:
            node = TreeNode(val)
            return node

        if root.val > val:
            root.left = self.insertIntoBST(root.left, val)
        if root.val < val:
            root.right = self.insertIntoBST(root.right, val)

        return root

迭代法
class Solution:
    def insertIntoBST(self, root, val):
        if root is None:  # 如果根节点为空，创建新节点作为根节点并返回
            node = TreeNode(val)
            return node

        cur = root
        parent = root  # 记录上一个节点，用于连接新节点
        while cur is not None:
            parent = cur
            if cur.val > val:
                cur = cur.left
            else:
                cur = cur.right

        node = TreeNode(val)
        if val < parent.val:
            parent.left = node  # 将新节点连接到父节点的左子树
        else:
            parent.right = node  # 将新节点连接到父节点的右子树

        return root

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

力扣链接
在这里插入图片描述

删除节点比添加节点麻烦，插入节点只要插到节点为none的地方就行，删除结点，可能要改变树的结构
删除的节点有以下情况
1.没找到删除的结点
2.删除的是叶子节点
3.删的节点，左不空有空，左空右不空
4.删的节点，左右都不空【最复杂】——》让右孩子继位

递归三步曲

递归参数和返回值：递归参数（root和key ）返回值 node
终止条件：当遍历的节点为空，return root
单层遍历逻辑：【首先明确，遍历一条边还是整个树？要遍历整棵树】
3.1 如果叶子结点直接删除，如果左为空或者右为空，返回另一个
3.2 如果左右都不空，要删除根节点，右孩子继承，左孩子放右孩子最左边的叶子节点

递归法【优先看这个！！】
class Solution:
    def deleteNode(self, root, key):
        if root is None:
            return root
        if root.val == key:
            if root.left is None and root.right is None:
                return None
            elif root.left is None:
                return root.right
            elif root.right is None:
                return root.left
            else:
                cur = root.right
                while cur.left is not None:
                    cur = cur.left
                cur.left = root.left
                return root.right
        if root.val > key:
            root.left = self.deleteNode(root.left, key)
        if root.val < key:
            root.right = self.deleteNode(root.right, key)
        return root

递归法
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

迭代法
class Solution:
    def deleteOneNode(self, target: TreeNode) -> TreeNode:
        """
        将目标节点（删除节点）的左子树放到目标节点的右子树的最左面节点的左孩子位置上
        并返回目标节点右孩子为新的根节点
        是动画里模拟的过程
        """
        if target is None:
            return target
        if target.right is None:
            return target.left
        cur = target.right
        while cur.left:
            cur = cur.left
        cur.left = target.left
        return target.right

    def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
        if root is None:
            return root
        cur = root
        pre = None  # 记录cur的父节点，用来删除cur
        while cur:
            if cur.val == key:
                break
            pre = cur
            if cur.val > key:
                cur = cur.left
            else:
                cur = cur.right
        if pre is None:  # 如果搜索树只有头结点
            return self.deleteOneNode(cur)
        # pre 要知道是删左孩子还是右孩子
        if pre.left and pre.left.val == key:
            pre.left = self.deleteOneNode(cur)
        if pre.right and pre.right.val == key:
            pre.right = self.deleteOneNode(cur)
        return root