✅DAY17 二叉树续 | 654.最大二叉树 | 617.合并二叉树 | 700.二叉搜索树中的搜索 | 98.验证二叉搜索树

654.最大二叉树

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        if len(nums) == 1: return TreeNode(nums[0])
        # 构造一个新返回节点
        node = TreeNode(0)
        maxValue = 0
        maxValueIndex = 0 
        for i in range(len(nums)):
            if nums[i] > maxValue:
                maxValue = nums[i]
                maxValueIndex = i
        node.val = maxValue
        if maxValueIndex > 0 :
            new_list = nums[:maxValueIndex]
            node.left = self.constructMaximumBinaryTree(new_list)
        if maxValueIndex < len(nums) -1 :
            new_list = nums[maxValueIndex+1:]
            node.right = self.constructMaximumBinaryTree(new_list)

        return node        

• 时间复杂度：O(n^2)，其中 n 是数组的长度。每次调用 max(nums) 和 nums.index() 需要 O(n)，而每次递归调用的规模会减小。

• 空间复杂度：O(n)，递归调用栈的最大深度在最坏情况下是 O(n)，如数组为递增或递减序列。

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)
        node = TreeNode(max_val)
        node.left = self.constructMaximumBinaryTree(nums[:max_index])
        node.right = self.constructMaximumBinaryTree(nusm[max_index+1:])
        return node

617.合并二叉树

解题思路：直接在原root1上进行改变，步数同步进行

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> 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.二叉搜索树中的搜索

BSF --> left.val < node.val < right.val

解题思路：递归法

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[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)

解题思路：迭代法

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

98.验证二叉搜索树

解题思路：递归法，通过构造一个vec list，将数值按照中序存入，最后判断是否是按照从小到大排序的

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

    def traversal(self, root):
        if not root: return 
        # 中序遍历-->就是按照从小到大返回
        self.traversal(root.left)
        self.vec.append(root.val)
        self.traversal(root.right)
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        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 isValidBST(self, root: Optional[TreeNode]) -> bool:
        stack = []
        cur = root
        pre = None  # 前一个节点

        while cur or len(stack) > 0:
            # 遍历到最左节点
            while cur:
                stack.append(cur)
                cur = cur.left  # 左

            # 处理当前节点
            cur = stack.pop()  # 中
            if pre is not None and cur.val <= pre.val:
                return False
            pre = cur  # 更新前一节点

            # 处理右子树
            cur = cur.right  # 右

        return True