代码随想录算法训练营Day20 | 654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树 | Python | 个人记录向

注：Day19是休息日。

654.最大二叉树

代码随想录：654.最大二叉树
Leetcode：654.最大二叉树

做题

思路有点繁琐，一开始还有个字符写错了，没看出来，问了chat才发现错误。但总体思路对了，类似于用中序+前序/后续构建唯一二叉树。

# 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 len(nums) == 1:
            return TreeNode(nums[0])

        max_ = max(nums)
        max_idx = nums.index(max_)

        root = TreeNode(max_)
        left_nums = nums[:max_idx].copy()  # copy函数不需要，浪费空间
        right_nums = nums[max_idx+1:].copy()
        if len(left_nums) > 0:
            self.construct(root, left_nums, True)
        if len(right_nums) > 0:
            self.construct(root, right_nums, False)
        return root


    def construct(self, node, nums_, is_left):
        max_ = max(nums_)
        max_idx = nums_.index(max_)

        new = TreeNode(max_)
        left_nums = nums_[:max_idx].copy()
        right_nums = nums_[max_idx+1:].copy()

        if is_left:
            node.left = new
        else:
            node.right = new

        if len(left_nums) > 0:
            self.construct(new, left_nums, True)
        if len(right_nums) > 0:
            self.construct(new, right_nums, False)
        if len(left_nums) == 0 and len(right_nums) == 0:
            return

看文章

简洁写法如下：

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
        if not nums:
            return None
        max_val = max(nums)
        max_index = nums.index(max_val)
        node = TreeNode(max_val)
        node.left = self.constructMaximumBinaryTree(nums[:max_index])
        node.right = self.constructMaximumBinaryTree(nums[max_index+1:])
        return node

617.合并二叉树

代码随想录：617.合并二叉树
Leetcode：617.合并二叉树

做题

# 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 root1 is None:
            if root2 is None:
                return None
            else:
                return root2
        if root2 is None:
            return root1

        root1.val = root1.val + root2.val
        
        if root1.left or root2.left:
            root1.left = self.mergeTrees(root1.left, root2.left)
        if root1.right or root2.right:
            root1.right = self.mergeTrees(root1.right, root2.right)

        return root1

看文章

思路差不多，可以简化。

class Solution:
    def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
        # 递归终止条件: 
        # 但凡有一个节点为空, 就立刻返回另外一个. 如果另外一个也为None就直接返回None. 
        if not root1: 
            return root2
        if not root2: 
            return root1
        # 上面的递归终止条件保证了代码执行到这里root1, root2都非空. 
        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：700.二叉搜索树中的搜索

做题

思路没问题，就是return有点懵，尝试了一下赋值给node再return，就AC了。

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root:
            return root

        if val == root.val:
            return root
        elif val < root.val:
            node = self.searchBST(root.left, val)
        else:
            node = self.searchBST(root.right, val)

        return node

看文章

思路没问题，可以直接在if里return。

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        if not root or root.val == val: 
            return root
        if root.val > val: 
            return self.searchBST(root.left, val)
        if root.val < val: 
            return self.searchBST(root.right, val)

98.验证二叉搜索树

代码随想录：98.验证二叉搜索树
Leetcode：98.验证二叉搜索树

做题

写出来基础逻辑，但掉进文章所述的“陷阱”里了。不能只判断左节点、右节点和root节点的关系，而是root的左子树都小于root，右子树都大于root。从测试用例中看出错误点了，但不知道怎么解决。

看文章

在中序遍历下，输出的二叉搜索树节点的数值是有序序列。有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。具体代码如下：

class Solution:
    def __init__(self):
        self.vec = []

    def traversal(self, root):
        if root is None:
            return
        self.traversal(root.left)
        self.vec.append(root.val)  # 将二叉搜索树转换为有序数组
        self.traversal(root.right)

    def isValidBST(self, root):
        self.vec = []  # 清空数组
        self.traversal(root)
        for i in range(1, len(self.vec)):
            # 注意要小于等于，搜索树里不能有相同元素
            if self.vec[i] <= self.vec[i - 1]:
                return False
        return True

以往忽略的知识点小结

• 注意看什么时候return
• 二叉搜索树的中序遍历，是有序数列

个人体会

完成时间：1h20min。
心得：算是复习了一下中序+前序/后序构建唯一二叉树，要注意一下什么时候return；做题之前必须熟悉前序、中序、后序、层序，有可能在一些树结构上有特殊的规律。

​