LeetCode Day22 | 235. 二叉搜索树的最近公共祖先、701. 二叉搜索树中的插入操作、450. 删除二叉搜索树中的节点

星空浩繁

已于 2023-05-07 19:31:38 修改

阅读量112

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法数据结构 python

于 2023-03-22 22:03:22 首次发布

本文链接：https://blog.csdn.net/m0_37830008/article/details/129720506

版权

LeetCode 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

本文介绍了如何在二叉搜索树中找到两个节点的最近公共祖先，以及如何进行插入和删除节点的操作。对于最近公共祖先，利用二叉搜索树的有序性可以简化问题，通过递归或迭代方法解决。在插入操作中，通过递归将新节点添加到适当位置。而删除节点则要考虑五种不同情况，包括叶子节点和非叶子节点的删除处理。

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

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

难度：☆3

本题利用二叉搜索树的有序性，不需要遍历整棵树，且不需要考虑 p、q 的大小关系。本题没有中间节点的处理逻辑，只有左右节点的，所以不区分前中后序遍历。

从根节点向下遍历，分三种情况讨论：（1）当前节点比 p、q 都大；（2）当前节点比 p、q 都小；（3）当前节点介于 p、q 之间。

一个关键思维难点需要考虑：

引理：从根节点向下遍历，出现的第一个介于 p、q 的值之间的节点 m 一定是 p、q 的最近公共祖先。
证明：从根节点向下遍历，当节点 m 是第一个介于 p、q 的值之间的节点时，p、q 分别在这个节点 m 的左右子树上。若从这个节点 m 出发，向左或向右遍历到孩子节点 n。那么 p 和 q 中必有一个不在新节点 n 的左右子树上。因此，节点 m 一定是 p、q 的最近公共祖先。

a. 递归法

详细版。

# 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.val > p.val and root.val > q.val:
            leftSubTree = self.lowestCommonAncestor(root.left, p, q)  # 左
            if leftSubTree:
                return leftSubTree
        elif root.val < p.val and root.val < q.val:
            rightSubTree = self.lowestCommonAncestor(root.right, p, q)  # 右
            if rightSubTree:
                return rightSubTree
        else:
            return root  # 找到结果

精简左右节点的逻辑。

        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)  # 右

不利用二叉搜索树的特性，用二叉树的通用解法（后序遍历）也可以通过，但要遍历整棵树。

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if not root or root == p or root == q:
            return root
        leftSubTree = self.lowestCommonAncestor(root.left, p, q)  # 左
        rightSubTree = self.lowestCommonAncestor(root.right, p, q)  # 右
        if leftSubTree and rightSubTree:  # 中
            return root  # 找到结果
        elif leftSubTree:
            return leftSubTree
        else:
            return rightSubTree

b. 迭代法

迭代法利用二叉搜索树的有序性，非常简洁。

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        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  # 找到结果

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

难度：☆2

根据题意，新节点都可以作为叶子节点插入，不需要考虑“可能存在多种有效的插入方式”，因为二叉树原有结构不用更改，增添叶子即可。

a. 递归法

递归法的实现有多种。遍历路线是从根节点到叶子节点的一条线。

借助无返回值的成员函数。

class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root:
            return TreeNode(val)
        self.traversal(root, val)
        return root
    
    def traversal(self, node: Optional[TreeNode], val: int) -> None:
        if val < node.val and node.left:  # 左
            self.insertIntoBST(node.left, val)
        elif val > node.val and node.right:  # 右
            self.insertIntoBST(node.right, val)
        elif val < node.val and not node.left:  # 左
            node.left = TreeNode(val)
            return
        elif val > node.val and not node.right:  # 右
            node.right = TreeNode(val)
            return

精简版，有返回值的原函数（写法 1）。关键：遇到叶子节点的时候，return TreeNode(val)，可以在叶子节点的下面插入新节点——递归调用返回上一级，将新节点赋给 root.left 或 root.right。

class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root:
            return TreeNode(val)
        if val < root.val:  # 左
            root.left = self.insertIntoBST(root.left, val)
        elif val > root.val:  # 右
            root.right = self.insertIntoBST(root.right, val)
        return root

有返回值的原函数（写法 2）。

class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        newNode = TreeNode(val)
        if not root:
            return newNode
        if not root.left and val < root.val:  # 左
            root.left = newNode
        elif not root.right and val > root.val:  # 右
            root.right = newNode
        elif val < root.val:  # 左
            self.insertIntoBST(root.left, val)
        elif val > root.val:  # 右
            self.insertIntoBST(root.right, val)
        return root

有返回值的原函数（写法 3）。

class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root:
            return TreeNode(val)
        if val < root.val:  # 左
            if not root.left:
                root.left = TreeNode(val)
            else:
                self.insertIntoBST(root.left, val)
        if val > root.val:  # 右
            if not root.right:
                root.right = TreeNode(val)
            else:
                self.insertIntoBST(root.right, val)
        return root

b. 迭代法：双指针

迭代法遍历的过程中，需要记录当前遍历节点的父节点，这样才能做插入节点的操作。用到记录 pre 和 cur 两个指针的技巧。

class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root:
            return TreeNode(val)
        cur = root
        while cur:  # 用循环不断寻找新节点的pre
            pre = cur  # 首先保存当前非空节点作为下一次迭代的父节点
            if val < cur.val:
                cur = cur.left
            elif val > cur.val:
                cur = cur.right
        # 跳出循环，新节点的pre已经找到，连接新节点和pre
        if val < pre.val:
            pre.left = TreeNode(val)
        elif val > pre.val:
            pre.right = TreeNode(val)
        return root

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

难度：☆4

a. 递归法

在递归函数的终止条件部分，有以下五种情况。

第一种情况：没找到要删除的节点，遍历到空节点直接返回。
找到要删除的节点：
第二种情况：删除节点的左右孩子都为空（叶子节点），直接删除节点，返回空为根节点。
第三种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点。
第四种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点。
第五种情况：删除节点的左右孩子都不为空，则将删除节点的左子树根节点（左孩子）放到删除节点的右子树最左侧节点的左孩子上，返回删除节点的右孩子为新的根节点。

第五种情况最复杂，改变树的结构是把左子树挂到右子树的最左侧，再删除根节点。用 cur 指针寻找右子树的最左侧节点。

递归调用，把新的节点返回给上一层，上一层就用 root.left 或者 root.right 接住。

class Solution:
    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        if not root:  # 没找到要删除的节点
            return None
        if key == root.val:  # 找到要删除的节点
            if not root.left and not root.right:  # 叶子节点，左空右空
                return None
            elif root.left and not root.right:  # 左不空右空
                return root.left
            elif not root.left and root.right:  # 左空右不空
                return root.right
            else:  # 左不空右不空
                cur = root.right
                while cur.left:
                    cur = cur.left
                cur.left = root.left
                return root.right
        if key < root.val:
            root.left = self.deleteNode(root.left, key)
        if key > root.val:
            root.right = self.deleteNode(root.right, key)
        return root