算法工程师重生之第十七天（二叉搜索树的最近公共祖先 二叉搜索树中的插入操作 .删除二叉搜索树中的节点）

参考文献 代码随想录

一、二叉搜索树的最近公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:

• 所有节点的值都是唯一的。
• p、q 为不同节点且均存在于给定的二叉搜索树中。

没有使用搜索二叉树的性质

# Definition for a binary tree node.
# 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):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if not root:  # 如果遇到空，那么就直接返回，这里使用的是后序遍历
            return
        if root.val == p.val or root.val == q.val: # 如果一遇到，与p或者是q值相等的，就直接返回，
            return root
        left = self.lowestCommonAncestor(root.left, p, q) # 需要从整颗数来看的话，就需要有返回值，如果是从边的话，那么就需要判断是否存在，然后递归
        right = self.lowestCommonAncestor(root.right, p, q)
        if left and right:  # 左右都发现，那么当前的值就是
            return root
        if not left and right:
            return right
        elif left and not right:
            return left
        else:
            return 
        return root        

性质

# Definition for a binary tree node.
# 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):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if not root:  # 如果遇到空，那么就直接返回，这里使用的是后序遍历
            return
        if root.val > p.val and root.val > q.val:  # 要么 都小于
            left = self.lowestCommonAncestor(root.left, p, q)
            if left is not None:
                return  left
        if root.val < p.val and root.val < q.val:  # 要么都大于
            right = self.lowestCommonAncestor(root.right, p, q)
            if right is not None:
                return right
        return root  # 要么有其中一个不等，或者是都不等

二、二叉搜索树中的插入操作

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

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

示例 1：

输入：root = [4,2,7,1,3], val = 5
输出：[4,2,7,1,3,5]
解释：另一个满足题目要求可以通过的树是：

示例 2：

输入：root = [40,20,60,10,30,50,70], val = 25
输出：[40,20,60,10,30,50,70,null,null,25]

示例 3：

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

提示：

• 树中的节点数将在 [0, 104]的范围内。
• -108 <= Node.val <= 108
• 所有值 Node.val 是 独一无二 的。
• -108 <= val <= 108
• 保证 val 在原始BST中不存在。

问题分析

        使用中序遍历，需要使用一个变量存储前一个遍历的值，因为，我们插入到的是叶子结点，如果当前的节点为空，那么需要知道它的上一个节点是什么，然后在判断应该放入左右，根据前一个节点的值判断，然后直接结束，最后返回即可。

# Definition for a binary tree node.
# 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 __init__(self):
        self.parent = None 
    def insertIntoBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        if root:
           return  self.dfs(root, val)
        else:
            return TreeNode(val)
    def dfs(self, cur,  val):
        if cur is None and self.parent:
            node = TreeNode(val)
            if val > self.parent.val:
                self.parent.right = node
            else:
                self.parent.left = node
            return

        self.parent = cur
        if cur.val > val:
            self.dfs(cur.left, val)
        if cur.val < val:
            self.dfs(cur.right, val)
        return cur
        

三、删除二叉搜索树中的节点

                                        

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

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

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

示例 1:

输入：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]。

示例 2:

输入: root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点

示例 3:

输入: root = [], key = 0
输出: []

提示:

• 节点数的范围 [0, 104].
• -105 <= Node.val <= 105
• 节点值唯一
• root 是合法的二叉搜索树
• -105 <= key <= 105

问题分析

        使用前序遍历，分为5中情况，找不到，找到了，左右都为空（也子节点），左为空，右不为空，返回右不为空，意思是删除当前节点它只存在右孩子，那么就把右孩子返回，就是下面的调用是roo.left = cur，假设，现在判断的是cur是删除的点，但是它存在右孩子，那么直接把它返回是不是就把cur给去掉了，左不为空，右为空，左右都不为空，最难的是这个，我们这里的思路是把的左孩子接到右孩子的左则，这样才能更接近父节点，如何借呢？首先你要找到右孩子的左最左边的，然后把要删除节点的左孩子赋值给它的左孩子，然后返回要删除节点的右孩子，这样会把当前要删除的节点给覆盖掉。如果当前的值大于要删除的值，那么就要往左遍历，反之，像右遍历。

递归

# Definition for a binary tree node.
# 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):
        """
        :type root: TreeNode
        :type key: int
        :rtype: TreeNode
        """
        if not root:
            return
        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 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 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 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