代码随想录算法训练营第十七天|654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树

最新推荐文章于 2026-04-22 21:06:04 发布

原创最新推荐文章于 2026-04-22 21:06:04 发布 · 248 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

654.最大二叉树

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

代码随想录

思路：做了昨天的最后一题，今天这道题就比较简单了，不过昨天为了理解方便，每一次都重新构建了数组，下面第一个方法就是这样，不过为了节省空间，可以用下标直接在原有数组上递归

# 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 constructMaximumBinaryTree(self, nums):
        """
        :type nums: List[int]
        :rtype: Optional[TreeNode]
        """
        if not nums:
            return None
        if len(nums)==1:
            return TreeNode(nums[0])
        max_pos=0
        for i in range(1,len(nums)):
            if nums[i]>nums[max_pos]:
                max_pos=i
        print(nums,max_pos,nums[max_pos])
        root=TreeNode(nums[max_pos])
        leftnums=nums[:max_pos]
        rightnums=nums[max_pos+1:]
        print(leftnums,rightnums)
        root.left=self.constructMaximumBinaryTree(leftnums)
        root.right=self.constructMaximumBinaryTree(rightnums)
        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 constructMaximumBinaryTree(self, nums):
        """
        :type nums: List[int]
        :rtype: Optional[TreeNode]
        """
        if not nums:
            return None
        if len(nums)==1:
            return TreeNode(nums[0])
        max_pos=0
        for i in range(1,len(nums)):
            if nums[i]>nums[max_pos]:
                max_pos=i
        print(nums,max_pos,nums[max_pos])
        root=TreeNode(nums[max_pos])
        root.left=self.constructMaximumBinaryTree(nums[:max_pos])
        root.right=self.constructMaximumBinaryTree(nums[max_pos+1:])
        return root

617.合并二叉树

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

代码随想录

思路：这道题可以主要依靠一颗树，如果两个节点都存在，就将值加到第一颗树上，需要注意的是，如果1不存在，就返回2，而如果2不存在，就返回1（不用专门写都不存在，因为刚刚的就会返回None）

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

700.二叉搜索树中的搜索

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

代码随想录

思路：可以利用二叉搜索树的性质（根节点比左子树所有数都大，比右子树所有数都小，而且根节点下的所有子节点都符合），用递归比较常规，而如果迭代就会很简洁，下面都分别给出

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

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

98.验证二叉搜索树

98. 验证二叉搜索树 - 力扣（LeetCode）

代码随想录

思路：利用二叉搜索树必须得使用中序遍历，因为上一题提到的性质，左中右必然是递增的。需要明确的是，这个递增不止存在于某一棵子树，而是存在于完整的数上，所以可以使用第一种方法，把所有的数存放在数组中，数组必须严格递增，才会是二叉搜索树。

# 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 isValidBST(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: bool
        """
        vec=[]
        def travel(root):
            if not root:
                return
            travel(root.left)
            vec.append(root.val)
            travel(root.right)
        travel(root)
        for i in range(1,len(vec)):
            if vec[i]<=vec[i-1]:
                return False
        return True

第二种方法本质上类似，也是使用中序遍历，不过会增加一个全程存在的变量max_val，因为二叉搜索树的性质，所以每一个递归到的节点必须大于当前的最大值，然后将自己的值赋值给最大值，否则就返回False

# 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 __init__(self):
        self.max_val=float('-inf')
    def isValidBST(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: bool
        """
        if not root:
            return True
        left=self.isValidBST(root.left)
        if root.val>self.max_val:
            self.max_val=root.val
        else:
            return False
        right=self.isValidBST(root.right)
        return left and right

标签

#算法