常见算法的进阶打怪路程|二叉树 05

臭nian

已于 2024-09-14 23:05:38 修改

阅读量148

点赞数 3

分类专栏：常见算法的进阶打怪路程文章标签：算法

于 2024-09-13 06:48:24 首次发布

本文链接：https://blog.csdn.net/Neptune_keke/article/details/142188925

版权

常见算法的进阶打怪路程专栏收录该内容

16 篇文章 0 订阅

订阅专栏

654. 最大二叉树 - 力扣（LeetCode）

# 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 constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return None
        mx=float('-inf')
        idx=0
        for i in range(len(nums)):
            if nums[i]>mx:
                mx=nums[i]
                idx=i
        root=TreeNode(val=mx)
        root.left=self.constructMaximumBinaryTree(nums[:idx])
        root.right=self.constructMaximumBinaryTree(nums[idx+1:])
        return root

617. 合并二叉树 - 力扣（LeetCode）

# 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 mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root2:
            return root1
        if not root1:
            return root2
        root=TreeNode(val=root1.val+root2.val)
        root.left=self.mergeTrees(root1.left,root2.left)
        root.right=self.mergeTrees(root1.right,root2.right)
        return root

700. 二叉搜索树中的搜索 - 力扣（LeetCode）

# 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 searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root:
            return None
        if root.val>val:
            return self.searchBST(root.left,val)
        elif root.val<val:
            return self.searchBST(root.right,val)
        else:
            return root

. - 力扣（LeetCode）

# 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 find(self,root):
        if not root:
            return []
        lf=self.find(root.left)
        rg=self.find(root.right)
        return lf+[root.val]+rg

    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        re=self.find(root)
        for i in range(1,len(re)):
            if re[i]<=re[i-1]:
                return False
        return True

#双指针法
# 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 find(self,node):
        if not node:
            return True
        lf=self.find(node.left)

        if self.pre and self.pre.val>=node.val:
            return False
        self.pre=node
        
        rg=self.find(node.right)
        return lf and rg
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        self.pre=None
        return self.find(root)