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

654.最大二叉树 - 🔗

讲解 - 🔗
💡这道题跟代码随想录算法训练营第十八天的最后两道题非常相似，是同一种思路，只需要通过找出数组中最大值的下标来划分左右子树即可。

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        # 中左右->类似于前序遍历
        # 第一步：设定终止条件,如果nums为空，说明该子树为空
        if not nums:
            return None
        # 第二步：找出最大值并创建根节点
        max_val = max(nums)
        root = TreeNode(max_val)
        # 第三步：找出最大值下标（因为数组是不重复的）
        max_index = nums.index(max_val)
        # 第四步：划分左右子树
        left = nums[:max_index]
        right = nums[max_index + 1:]
        # 第五步：递归创建左右子树
        root.left = self.constructMaximumBinaryTree(left)
        root.right = self.constructMaximumBinaryTree(right)

        return root

617.合并二叉树 - 🔗

讲解 - 🔗
💡分为四种情况，其中root1和root2均为空为终止条件。

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        # 终止条件：当root1和root2均为空时
        if not root1 and not root2:
            return None

        # root1不为空，root2为空
        if root1 and not root2:
            root = TreeNode(root1.val)
            root.left = self.mergeTrees(root1.left, None)
            root.right = self.mergeTrees(root1.right, None)
        # root1为空，root2不为空
        elif not root1 and root2:
            root = TreeNode(root2.val)
            root.left = self.mergeTrees(None, root2.left)
            root.right = self.mergeTrees(None, root2.right)
        # root1和root2均不为空
        else:
            root = TreeNode(root1.val + root2.val)
            root.left = self.mergeTrees(root1.left, root2.left)
            root.right = self.mergeTrees(root1.right, root2.right)

        return root

700.二叉搜索树中的搜索 - 🔗

讲解 - 🔗

方法一：不了解二叉搜索树特性

💡这道题自己做的时候，根本不知道什么是二叉搜索树，就直接做了，所以不如增加判断节点值大小的方法高效。

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

        if root.val == val:
            self.res = root
            return

        left = self.match(root.left, val)
        right = self.match(root.right, val)

    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        self.res = None
        self.match(root, val)
        return self.res

方法二：递归

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        # 为什么要有返回值: 
        #   因为搜索到目标节点就要立即return，
        #   这样才是找到节点就返回（搜索某一条边），如果不加return，就是遍历整棵树了。

        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)

方法三：迭代

class Solution:
    def searchBST(self, root: TreeNode, val: int) -> TreeNode:
        while root:
            if val < root.val: root = root.left
            elif val > root.val: root = root.right
            else: return root
        return None

98.验证二叉搜索树 - 🔗

讲解 - 🔗
💡自己做的时候根本连暴力解法都没想到，直接想的是双指针，但是写着写着又绕进去了。

方法一：递归法 - 利用中序递增性质，转换成数组

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

方法二：递归法 - 直接取该树的最小值

class Solution:
    def __init__(self):
        self.pre = None  # 用来记录前一个节点

    def isValidBST(self, root):
        if root is None:
            return True

        left = self.isValidBST(root.left)

        if self.pre is not None and self.pre.val >= root.val:
            return False
        self.pre = root  # 记录前一个节点

        right = self.isValidBST(root.right)
        return left and right