代码随想录训练营第22天 | 235. 二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作、450.删除二叉搜索树中的节点

最新推荐文章于 2024-06-16 20:54:56 发布

Jack199274

最新推荐文章于 2024-06-16 20:54:56 发布

阅读量32

点赞数

分类专栏：数据结构和算法文章标签：算法

本文链接：https://blog.csdn.net/Jack199274/article/details/133327793

版权

数据结构和算法专栏收录该内容

72 篇文章 2 订阅

订阅专栏

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

题目链接：

解法：

因为是有序树，所有如果中间节点是 q 和 p 的公共祖先，那么中节点的数组一定是在 [p, q]区间的。即中节点 > p && 中节点 < q 或者中节点 > q && 中节点 < p。但这个条件写起来麻烦，所以作为else的部分去写。

关键的一点是要理解：当我们从上向下去递归遍历，第一次遇到 cur节点是数值在[p, q]区间中，那么cur就是 p和q的最近公共祖先。不仅是公共祖先，还是最近的。

如果cur节点的数值都大于这两个节点的，那么最近公共祖先得去cur的左子树找，如果都小于，则去cur的右子树找。一旦其中一条边找到了，里面返回，不用遍历整棵树。

根据一定有解，没有null值，可以简化代码，不用判断为null的情况。

迭代法的情况，可以不用栈和队列，直接使用节点进行迭代。

边界条件：

时间复杂度：O(n)

空间复杂度：

# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

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

    def traversal(self, cur, p, q):
        if not cur:
            return None
        # 如果都大于，则说明p和q都在左子树
        if cur.val > p.val and cur.val > q.val:
            # 如果left不为None，则说明找到满足条件的公共祖先了
            left = self.traversal(cur.left, p, q)
            if left:
                return left
        if cur.val < p.val and cur.val < q.val:
            right = self.traversal(cur.right, p, q)
            if right:
                return right

        # 不知道p和q那个的val更大，这个else的条件包含了两种情况，
        # 但都是表明cur的val在p和q之间
        return cur

# 递归法：精简版
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    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 TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    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

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

题目链接：二叉搜索树中的插入操作

解法：

递归法：比较简单直观，根据二叉搜索树的性质，可以根据插入元素的数值，决定递归方向。不需要搜索整棵树。遍历到节点为空，那么用值构造节点。一定有解，所以可以简化某些环节不用判断null值。

迭代法：不用栈和队列，而是使用双指针。在迭代法遍历的过程中，需要记录一下当前遍历的节点的父节点，这样才能做插入节点的操作。使用cur和parent指针，如果cur为null了，那么parent的左节点或者右节点就是新构造的节点。

边界条件：root为空，直接把插入的数值构造root

时间复杂度：

空间复杂度：

# 递归法
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def insertIntoBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        # 解决边界条件：如果root为空，则由val构造root
        if not root:
            return TreeNode(val)
        
        # 如果小于当前的值，则在左子树中插入
        if root.val > val:
            # 一定能插入，所以不用判断是否为None了
            root.left = self.insertIntoBST(root.left, val)
        else:
            root.right = self.insertIntoBST(root.right, val)
            
        return root

# 迭代法
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def insertIntoBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        if not root:
            return TreeNode(val)

        cur = root
        parent = root
        while cur:
            parent = cur
            if cur.val > val:
                cur = cur.left
            else:
                cur = cur.right

        node = TreeNode(val)
        if parent.val > val:
            parent.left = node
        else:
            parent.right = node
        return root

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

题目链接：删除二叉搜索树的节点

解法：

这道题的难点在于，要把二叉搜索树中删除节点遇到的情况都搞清楚。

有以下五种情况：

第一种情况：没找到删除的节点，就根据数值的大小，向左或者右子树进行递归，遍历到空节点直接返回了。
找到删除的节点
- 第二种情况：左右孩子都为空（叶子节点），直接删除节点，返回NULL为根节点
- 第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
- 第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
- 第五种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左面节点的左孩子上，返回删除节点右孩子为新的根节点。

第五种情况是为了保持二叉搜索树的有序性，右子树的最左面的节点是右子树上数值最小的，但大于左子树的所有值。

迭代法比较复杂，不去掌握了。

边界条件：根节点为空。

时间复杂度：

空间复杂度：

# 递归法
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def deleteNode(self, root, key):
       
        return self.traversal(root, key)

    def traversal(self, root, key):
        if not root:
            return None

        if root.val == key:
            if not root.left and not root.right:
                return None
            elif root.left and not root.right:
                return root.left
            elif root.right and not root.left:
                return root.right
            else:
                # 这里的实现有点麻烦，有点绕。没有使用各种指针
                cur = root.right
                while cur.left:
                    cur = cur.left
                cur.left = root.left
                return root.right
        elif root.val > key:
            root.left = self.traversal(root.left, key)
            return root
            
        elif root.val < key:
            root.right = self.traversal(root.right, key)
            return root