蓝桥杯第九天二叉搜索树（2）

最新推荐文章于 2024-03-21 10:53:58 发布

是小肖啊！

最新推荐文章于 2024-03-21 10:53:58 发布

阅读量2k

点赞数

文章标签：蓝桥杯 leetcode 职场和发展

本文链接：https://blog.csdn.net/aixiaoxiao13/article/details/122731325

版权

1.235. 二叉搜索树的最近公共祖先 - 力扣（LeetCode） (leetcode-cn.com)

2.701. 二叉搜索树中的插入操作 - 力扣（LeetCode） (leetcode-cn.com)

3.450. 删除二叉搜索树中的节点 - 力扣（LeetCode） (leetcode-cn.com)

4.669. 修剪二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com)

5.108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com)

6.538. 把二叉搜索树转换为累加树 - 力扣（LeetCode） (leetcode-cn.com)

1.235. 二叉搜索树的最近公共祖先 - 力扣（LeetCode） (leetcode-cn.com)

# 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==None:
            return None
        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)
        return root

2.701. 二叉搜索树中的插入操作 - 力扣（LeetCode） (leetcode-cn.com)

# 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: TreeNode, val: int) -> TreeNode:
        if not root:
            return TreeNode(val)
        if root.val>val:
            root.left=self.insertIntoBST(root.left,val)
        if root.val<val:
            root.right=self.insertIntoBST(root.right,val)
        return root

3.450. 删除二叉搜索树中的节点 - 力扣（LeetCode） (leetcode-cn.com)

# 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 root
        if root.val==key:
            if not root.left and not root.right:
                del root
                return None
            if not root.left and root.right:
                change=root.right
                del root
                return change
            if not root.right and root.left:
                change=root.left
                del root.left
                return change
            if root.right and root.left:
                l=root.right
                while l.left:
                    l=l.left
                l.left=root.left
                change=root.right
                del root
                return change
        
        if root.val>key:root.left=self.deleteNode(root.left,key)
        if root.val<key:root.right=self.deleteNode(root.right,key)
        return root

4.669. 修剪二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com)

# 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 trimBST(self, root: Optional[TreeNode], low: int, high: int) -> Optional[TreeNode]:
        if root==None:
            return None
        
        if root.val<low:
            return self.trimBST(root.right,low,high)
        if root.val>high:
            return self.trimBST(root.left,low,high)
        root.left=self.trimBST(root.left,low,high)
        root.right=self.trimBST(root.right,low,high)
        return root

5.108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com)

# 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 sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        if not nums:
            return None
        index=len(nums)//2
        rootnode=nums[index]
        root=TreeNode(rootnode)
        root.left=self.sortedArrayToBST(nums[:index])
        root.right=self.sortedArrayToBST(nums[index+1:])
        return root

6.538. 把二叉搜索树转换为累加树 - 力扣（LeetCode） (leetcode-cn.com)

# 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 convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        pre=0
        def traversal(root):
            nonlocal pre
            if not root:
                return
            traversal(root.right)
            root.val+=pre
            pre=root.val
            traversal(root.left)
        traversal(root)
        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 convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        stack=[]
        pre=0
        cur=root
        while cur or stack:
            if cur:
                stack.append(cur)
                cur=cur.right
            else:
                cur=stack.pop()
                cur.val+=pre
                pre=cur.val
                cur=cur.left
        return root