Leetcode刷题笔记1 二叉树part05

leetcode654 最大二叉树

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

leetcode617 合并二叉树

觉得二叉树的学习过程中递归很好使，随着题目的增加，对递归理解更加深刻

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

leetcode700 二叉搜索树中的搜索

递归法：

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 val < root.val: root = root.left
            elif val > root.val: root = root.right
            else:return root
        return None

leetcode98 验证二叉搜索树

先通过中序遍历将二叉树转为有序数组，判断数组是否有序就行

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 __init__(self):
        self.maxVal = float('-inf')

    def isValidBST(self, root: TreeNode):
        if not root:
            return True
        left = self.isValidBST(root.left)
        if self.maxVal < root.val:
            self.maxVal = root.val
        else:
            return False
        right = self.isValidBST(root.right)
        return left and right

 迭代法

在此题中，由于深度遍历方法的遗忘废了些功夫，需要常复习三种迭代遍历方式

class Solution:
    def isValidBST(self, root):
        stack = []
        cur = root
        pre = None
        while cur is not None or len(stack) > 0:
            if cur is not None:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                if pre is not None and cur.val <= pre.val:
                    return False
                pre = cur 
                cur = cur.right
        return True