DAY20 二叉树part06

654.最大二叉树

这个思路可以理解但我想不到

# 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]:
        # 使用单调栈优化
        stack = []
        for num in nums:
            cur = TreeNode(num)
            while stack and stack[-1].val <num:
                cur.left = stack.pop()
            if stack:
                stack[-1].right = cur
            stack.append(cur)
        return stack[0]

# 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]:
        return self.findmaxTree(nums,0,len(nums))
    # 构造findmaxTree函数，找到区间内的最大值构造为当前二叉树的根节点
    # 则最大值左边区间递归到二叉树的左子树
    # 最大值右边区间低轨道二叉树的右子树
    def findmaxTree(self,nums:List[int],start,end):
        # 终止条件：区间内没有数字
        if start ==end:
            return None
        # 初始化最大值的下标
        maxindex = start
        # 寻找最大值的下标
        for i in range(start+1,end):
            if nums[i] > nums[maxindex]:
                maxindex = i
        # 构造根节点
        root = TreeNode(nums[maxindex])
        # 递归左子树
        root.left = self.findmaxTree(nums,start,maxindex)
        # 递归右子树
        root.right = self.findmaxTree(nums,maxindex+1,end)

        return root

617.合并二叉树

我的错误代码

• 首先当root1和root2都为空时，应该返回None。只有在两个节点都不为空时，才应该创建一个新节点root
• 其次在elif not root1: root = TreeNode(root2.val) elif not root2: root = TreeNode(root1.val) else: root = TreeNode(root1.val+root2.val)中对root多次赋值，最后一次赋值覆盖了前面的赋值

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1 and not root2:
            root = None
        elif not root1:
            root = TreeNode(root2.val)
        elif not root2:
            root = TreeNode(root1.val)
        else:
            root = TreeNode(root1.val+root2.val)
        if not root:return None
        root.left = self.mergeTrees(root1.left,root2.left)
        root.right = self.mergeTrees(root1.right,root2.right)
        return root

正确代码

# 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 not root1 and not root2:
            return None
        elif not root1:
            return root2
        elif not root2:
            return root1
        root = TreeNode(root1.val+root2.val)
        # if not root:return None
        root.left = self.mergeTrees(root1.left,root2.left)
        root.right = self.mergeTrees(root1.right,root2.right)
        return root

迭代法 感觉好复杂

# 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]:
        # 如果root1为空，则合并后节点为root2
        if not root1:
            return root2
        # 如果root2为空，则合并后节点为root1
        if not root2:
            return root1
        # 如果都存在节点，创建一个新的节点存储合并后的值
        root = TreeNode(root1.val+root2.val)
        # 初始化队列
        queueMerge = [root]
        queue = [root1,root2]

        while queue:
            # 从队列中取出当前节点
            node = queueMerge.pop(0)
            node1 = queue.pop(0)
            node2 = queue.pop(0)
            if node1.left or node2.left:
                # 若两棵树的左孩子都存在
                if node1.left and node2.left:
                    leftMerge = TreeNode(node1.left.val + node2.left.val)
                    node.left = leftMerge
                    queueMerge.append(leftMerge)
                    queue.append(node1.left)
                    queue.append(node2.left)
                # 若只有一棵树存在左孩子 则直接赋值
                elif node1.left:
                    node.left = node1.left
                elif node2.left:
                    node.left = node2.left
            if node1.right or node2.right:
                # 若两棵树的右孩子都存在
                if node1.right and node2.right:
                    rightMerge = TreeNode(node1.right.val+node2.right.val)
                    node.right = rightMerge
                    queueMerge.append(rightMerge)
                    queue.append(node1.right)
                    queue.append(node2.right)
                # 若只有一棵树存在右孩子，直接赋值
                elif node1.right:
                    node.right = node1.right
                elif node2.right:
                    node.right = node2.right
        return root

700.二叉搜索树中的搜索

递归

# 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 searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if not root: return None

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

• 时间复杂度O(n) 空间复杂度O(n)

迭代

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

• 时间复杂度O(n) 空间复杂度O(1)

98.验证二叉搜索树

错误代码：问题出在对左子树和右子树进行递归检查时，虽然检查了值的大小关系，但是没有正确地更新边界值。对于左子树，右边界应该是根节点的值；对于右子树，左边界应该是根节点的值。

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        if not root: return True
        
        # 若当前节点的左子树存在
        if root.left:
            # 当该节点的左子树的值小于当前节点，则递归到左子树
            if root.left.val >= root.val:
                return False
            if not self.isValidBST(root.left):
                return False

        # 若当前节点的右子树存在
        if root.right:
            if root.right.val <= root.val:
                return False
            if not self.isValidBST(root.right):
                return False

        return True

正确代码

# 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 isValidBST(self, root: Optional[TreeNode]) -> bool:
        return self.dg(root,float('-inf'),float('inf'))
    def dg(self,root,minval,maxval):
        # 若当前节点为空 证明已经递归到了叶子节点 返回True
        if not root:return True
        # 如果当前节点值符合规定，则进行递归
        if root.val < maxval and root.val >minval:
            pass
        else:
            return False
        # 对左子树进行递归，此时最大值应该为当前节点值
        if not self.dg(root.left,minval,root.val):
            return False
        # 对右子树进行递归，此时最小值应该为当前节点值
        if not self.dg(root.right,root.val,maxval):
            return False
        return True