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

654. 最大二叉树

leetcode 654. 最大二叉树
代码随想录

弄清楚题目的定义：左子树是有max——value左边的元素构成，右子树是由右边的元素构成

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        # print(nums)
        if len(nums) == 1:
            return TreeNode(nums[0])
        max_value = 0
        max_value_index = 0
        for i in range(len(nums)):
            if nums[i] > max_value:
                max_value = nums[i]
                max_value_index = i
        node = TreeNode(max_value)
        # 左子树
        if max_value_index > 0:
            node.left = self.constructMaximumBinaryTree(nums[:max_value_index])
        # 右子树
        if max_value_index < len(nums) - 1:
            node.right = self.constructMaximumBinaryTree(nums[max_value_index+1:])
        return node

617. 合并二叉树

leetcode 617. 合并二叉树
代码随想录

递归，同时遍历。终止条件是都为空，其中一个为空。

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        # 如果不为空 合并
        node = TreeNode(0)
        if root1 and root2:
            node.val = root1.val +root2.val
        # 如何有一个为空，直接链接
        elif not root1:
            # root1 空
            return root2
        elif not root2:
            return root1
        # 没有return说明都不为空，然后就可以继续深入下去
        node.left = self.mergeTrees(root1.left, root2.left)
        node.right = self.mergeTrees(root1.right, root2.right)
        return node

700. 二叉搜索树中的搜索

leetcode 700. 二叉搜索树中的搜索
代码随想录

二叉搜索树的特点，根节点一定大于左子树的所有节点，一定小于右子树的所有节点（等于呢？）

class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        '''
        二叉搜索树的特点:
        左边比跟节点小，右边比根节点大
        '''
        if not root:
            return None
        root_val = root.val
        if root_val == val:
            return root
        elif root_val > val:
            return self.searchBST(root.left, val)
        else:
            return self.searchBST(root.right, val)

98. 验证二叉搜索树

leetcode 98. 验证二叉搜索树
代码随想录

解法1，使用一个上下界，然后递归。

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        def check(root, min_, max_):
            if not root:
                return True
            if min_ >= root.val or max_ <= root.val:
                return False
            if not check(root.left, min_, root.val):
                return False
            if not check(root.right, root.val, max_):
                return False
            return True
        return check(root, -float('inf'), float('inf'))

解法2.利用特性进行中序遍历，然后看是不是严格递增的序列。

class Solution:
    def isValidBST(self, root: Optional[TreeNode]) -> bool:
        # return True
        # 直接硬递归就傻乎乎的了。
        # 中序遍历，然后看是不是排好序的就行了
        inorder = []
        def traverse(root):
            if not root:
                return
            traverse(root.left)
            inorder.append(root.val)
            traverse(root.right)
        traverse(root)
        # 有相同元素
        # if len(set(inorder)) != len(order):
            # return False
        pre_val = inorder[0]
        for i in range(1,len(inorder)):
            if inorder[i] <= pre_val:
                return False
            else:
                pre_val = inorder[i]
        return True
        # print(inorder)