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

[参考链接]

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

[注意]

1.因为是有序树，所以如果中间节点是 q 和 p 的公共祖先，那么中间节点的数组 一定是在[p, q]区间的。即中节点 > p && 中节点 < q 或者 中节点 > q && 中节点 < p。

2.那么只要从上到下去遍历，遇到 cur节点是数值在[p, q]区间中则一定可以说明该节点cur就是q 和 p的公共祖先。 

3.遍历顺序无所谓,没有中间处理逻辑,只要有一个左一个右就可以.

[代码]

# 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
        """
        #1.递归法
        #左
        if root.val > p.val and root.val > q.val:
            return self.lowestCommonAncestor(root.left, p, q)
        #右
        if root.val < p.val and root.val < q.val:
            return self.lowestCommonAncestor(root.right, p, q)
        #cur处在中间
        return root

        #2.迭代法
        while True:
            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. 二叉搜索树中的插入操作

[注意]

1.只要遍历二叉搜索树，找到空节点 插入元素就可以了，

2.把添加的节点返回给上一层，就完成了父子节点的赋值操作了，

[代码]

# 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 insertIntoBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        # 返回更新后的以当前root为根节点的新树，方便用于更新上一层的父子节点关系链

        # Base Case
        if not root: return TreeNode(val)

        # 单层递归逻辑:
        if val < root.val: 
            # 将val插入至当前root的左子树中合适的位置
            # 并更新当前root的左子树为包含目标val的新左子树
            root.left = self.insertIntoBST(root.left, val)

        if root.val < val:
            # 将val插入至当前root的右子树中合适的位置
            # 并更新当前root的右子树为包含目标val的新右子树
            root.right = self.insertIntoBST(root.right, val)

        # 返回更新后的以当前root为根节点的新树
        return root

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

[注意]

1.删除操作通过返回值进行操作,在停止条件里进行处理.

2.有以下五种情况：

• 第一种情况：没找到删除的节点，遍历到空节点直接返回了
• 找到删除的节点
  • 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
  • 第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
  • 第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
  • 第五种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左面节点的左孩子上，返回删除节点右孩子为新的根节点.
  • [代码]

  • # 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
            """
            #1.递归法
            if not root:#根节点为空,情况1
            #第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回None为根节点
                return None
            #向右遍历
            if key > root.val:
                root.right = self.deleteNode(root.right, key)
            #向左
            elif key < root.val:
                root.left = self.deleteNode(root.left, key)
     
            else:
                #第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
                if not root.left:
                    return root.right
    
                #第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
    
                if not root.right:
                    return root.left
    
                # 情况五:左右子树都不为空，找到右孩子的最左节点 记为node
                node = root.right
                while node.left:#右孩子左节点不为空,一直遍历
                    node = node.left
                # 将当前节点的左子树挂在node的左孩子上
                node.left = root.left
                # 当前节点的右子树替换掉当前节点，完成当前节点的删除
                root = root.right
    
            return root