DAY22二叉树 part08

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

# 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':
        # 保持p.val<q.val
        if p.val > q.val:p,q = q,p
        while root:
            # 若root小于p则说明pq都在root的右子树上
            if root.val < p.val:
                root = root.right
            # 若root大于q则说明pq都在root的左子树上
            elif root.val > q.val:
                root = root.left
            else:break
        return root

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

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

不理解为啥这个直接超过时间限制了

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        while root:
            if val > root.val:
                if not root.right:
                    New = TreeNode(val)
                    root.right = New
                else:
                    root = root.right
            if val < root.val:
                if not root.left:
                    New = TreeNode(val)
                    root.left = New
                else:
                    root = root.left
        return root

正确代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root:
            return TreeNode(val)
        pos = root
        while pos:
            if val > pos.val:
                if not pos.right:
                    pos.right = TreeNode(val)
                    break
                else:
                    pos = pos.right
            if val < pos.val:
                if not pos.left:
                    pos.left = TreeNode(val)
                    break
                else:
                    pos = pos.left
        return root

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

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        if not root:return None
        if root.val > key:
            root.left = self.deleteNode(root.left,key)
        elif root.val < key:
            root.right = self.deleteNode(root.right,key)
        else:
            if not root.left or not root.right:
                root = root.left if root.left else root.right
            else:
                node = root.right
                while node.left:
                    node = node.left
                # 若key左右子树都有，将key的位置替换为右子树的最小值
                root.val = node.val
                # 删除右子树的最小值
                root.right = self.deleteNode(root.right,node.val)
        return root

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:

    def deleteOneNode(self, root):
        if root.left == None and root.right == None:
            root = None
            return root
        elif root.left != None and root.right == None:
            return root.left
        elif root.left == None and root.right != None:
            return root.right
        else:
            node = root.right
            while node.left:
                node = node.left
            node.left = root.left
            return root.right

    def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
        if root == None:
            return None

        cur = root
        # 记录 cur 节点的父节点
        pre = None

        while cur:
            if cur.val == key:
                break
            pre = cur
            if cur.val > key:
                cur = cur.left
            else:
                cur = cur.right
        # 如果只有一个根节点
        if pre == None:
            return self.deleteOneNode(cur)
        # 要删除的 key 在左孩子
        if pre.left != None and pre.left.val == key:
            pre.left = self.deleteOneNode(cur)
        # 要删除的 key 在右孩子
        if pre.right != None and pre.right.val == key:
            pre.right = self.deleteOneNode(cur)
        return root