代码随想录｜Day17｜二叉树06｜654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树-CSDN博客

本文链接：https://blog.csdn.net/EANFSKK/article/details/136626879

654.最大二叉树

和 105、106构造二叉树 一样，我们使用递归，每一层确定根节点和左右子树元素。

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if not nums:
            return None

        max_val = max(nums)
        max_index = nums.index(max_val)

        root = TreeNode(max_val)
        root.left = self.constructMaximumBinaryTree(nums[:max_index])
        root.right = self.constructMaximumBinaryTree(nums[max_index+1:])

        return root

617.合并二叉树

合并两棵二叉树可以通过递归地方式实现。在递归过程中，我们考虑三种情况：

两个节点都不为None：将它们的值相加，然后递归地合并它们的左子树和右子树。
一个节点为None：直接返回另一个节点作为合并后的节点。
两个节点都为None：直接返回None。

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        # 如果两个节点都为None，则直接返回None
        if not root1 and not root2:
            return None
        # 如果其中一个为None，返回另一个节点
        elif not root1:
            return root2
        elif not root2:
            return root1
        # 如果都不为None，则节点值相加
        else:
            root1.val += root2.val
            # 递归合并左右子树
            root1.left = self.mergeTrees(root1.left, root2.left)
            root1.right = self.mergeTrees(root1.right, root2.right)
            return root1

700.二叉搜索树中的搜索

首先回顾一下二叉搜索树的定义：对于任意节点，其左子树中的所有节点都小于该节点，右子树中的所有节点都大于该节点。

思路：从根节点开始搜索，将目标值与当前节点值比较：

目标值 < 当前节点值，搜索左子树
目标值 > 当前节点值，搜索右子树
目标值 = 当前节点值，返回当前节点。

递归地搜索，直到找到值相等的节点，或者遍历到空节点。

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        # 如果节点为空，则表明到达了叶子结点，没有找到
        if not root:
            return None
        # 如果找到了目标值，返回当前节点
        if  val == root.val:
            return root
        # 当前值和目标值对比，确定迭代方向
        elif val < root.val:
            return self.searchBST(root.left, val)
        else:
            return self.searchBST(root.right, val)

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        # 迭代法
        while root:
            if val == root.val:
                return root
            elif val < root.val:
                root = root.left
            else:
                root = root.right
        return None

98.验证二叉搜索树

按照中序遍历，如果遍历结果是单调递增的，说明是二叉搜索树。

由此可以引出两个思路：

中序遍历二叉树，查看结果数组是否为单调递增。
中序遍历二叉树，过程追踪当前遍历的最后一个值，确保每个后续节点都更大。

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        # 中序遍历：递归
        # 创建数组
        def inorderTraversal(node):
            if not node:
                return []
            left = inorderTraversal(node.left)
            right = inorderTraversal(node.right)
            return left + [node.val] + right
        
        result = inorderTraversal(root)
        # 查看是否为单调递增
        for i in range(1, len(result)):
            if result[i] <= result[i-1]:
                return False
        
        return True

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        # 中序遍历：递归
        # 对比极值
        self.last_node_val = float('-inf')
 
        def inorderTraversal(node):
 
            if not node:
                return True
            # 左
            left = inorderTraversal(node.left)
            # 中
            if self.last_node_val < node.val:
                self.last_node_val = node.val
            else:
                return False
            # 右
            right = inorderTraversal(node.right)
            # 确保当前节点的整棵左子树和右子树都满足二叉搜索树（BST）的条件。
            return left and right
        
        return inorderTraversal(root)