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

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

• 题目链接：235. 二叉搜索树的最近公共祖先
• 遍历BST第一个值在pq之间的节点即为公共祖先
• 递归法

# 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 None
        
        if root.val<p.val and root.val<q.val:
            return self.lowestCommonAncestor(root.right, p, q)
        elif root.val>p.val and root.val>q.val:
            return self.lowestCommonAncestor(root.left, p, q)
        else:
            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
        """
        while root:    
            if root.val<p.val and root.val<q.val:
                root = root.right
            elif root.val>p.val and root.val>q.val:
                root = root.left
            else:
                return root
        
        return None

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

• 题目链接：701.二叉搜索树中的插入操作
• 遍历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 insertIntoBST(self, root, val):
        """
        :type root: TreeNode
        :type val: int
        :rtype: TreeNode
        """
        newNode = TreeNode(val = val)
        
        if not root:
            return newNode
        
        if root.val>val:
            root.left = self.insertIntoBST(root.left, val)
        else:
            root.right = self.insertIntoBST(root.right, val)

        return root

• 迭代

# 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
        """

        cur = root
        pre = root
        newNode = TreeNode(val = val)

        if not root:
            return newNode
        
        while cur:
            pre = cur
            if cur.val>val:
                cur = cur.left
            else:
                cur = cur.right
            
        if val>pre.val:
            pre.right=newNode
        else:
            pre.left = newNode
        
        return root

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

• 题目链接：450. 删除二叉搜索树中的节点
• 递归

# 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 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 not root.left and root.right:
                return root.right
            elif root.left and root.right:
                cur = root.right
                while cur.left:
                    cur = cur.left
                cur.left = root.left
                return root.right

        
        root.left = self.deleteNode(root.left, key)
        root.right = self.deleteNode(root.right, key)

        return root

• 迭代
  • 单独考虑只有一个头结点的情况

# 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 deletetarget(self, target):
        if not target.left and not target.right:
            return None
        elif target.left and not target.right:
            return target.left
        elif not target.left and target.right:
            return target.right
        elif target.left and target.right:
            cur = target.right
            while cur.left:
                cur = cur.left
            cur.left = target.left
            return target.right


    def deleteNode(self, root, key):
        """
        :type root: TreeNode
        :type key: int
        :rtype: TreeNode
        """

        if not root:
            return None

        cur = root
        pre = None
        
        while cur:
            if cur.val == key:
                break
            pre = cur
            if cur.val<key:
                cur = cur.right
            else:
                cur = cur.left
        
        if not pre:
            return self.deletetarget(root)

        if pre.left and pre.left.val==key:
            pre.left = self.deletetarget(cur)
        if pre.right and pre.right.val==key:
            pre.right = self.deletetarget(cur)

        return root