Leetcode| 654. 最大二叉树、617. 合并二叉树、700. 二叉搜索树中的搜索、98.验证二叉搜索树 Day20

最新推荐文章于 2024-10-20 09:49:14 发布

把瓶子洗干净

最新推荐文章于 2024-10-20 09:49:14 发布

阅读量362

点赞数

分类专栏：算法文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/wh1234546/article/details/128203621

版权

算法专栏收录该内容

54 篇文章 0 订阅

订阅专栏

654. Maximum Binary Tree

递归，当数组长度为1时即是终止条件，返回叶子节点
采用先序，中左右
中节点是值最大的那个，然后左右递归，要保证左右区间都至少有一个数值

# 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]:
        # 终止条件，叶子节点
        if len(nums) == 1:
            return TreeNode(nums[0])
        
        # 中
        maxVal = max(nums)
        index = nums.index(maxVal)
        node = TreeNode(maxVal)

        # 左
        if index > 0:   # 保证左区间至少有一个数值
            leftNum = nums[:index]
            node.left = self.constructMaximumBinaryTree(leftNum)

        # 右
        if index < len(nums) - 1:   # 保证右区间至少有一个数值
            rightNum = nums[index + 1:]
            node.right = self.constructMaximumBinaryTree(rightNum)

        return node

允许空节点进入递归，不需要加判断来保证左右区间都至少有一个数值

class Solution:
    def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
        # 终止条件
        if not nums:
            return None
        
        # 中
        maxVal = max(nums)
        index = nums.index(maxVal)
        node = TreeNode(maxVal)

        # 左
        leftNum = nums[:index]
        node.left = self.constructMaximumBinaryTree(leftNum)

        # 右
        rightNum = nums[index + 1:]
        node.right = self.constructMaximumBinaryTree(rightNum)

        return node

617. Merge Two Binary Trees

递归，合并到tree1

终止条件是某一棵树为空
单层递归中，就要把两棵树的元素加到一起

# 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 root1 == None: return root2  # 如果root1为空，返回root2
        if root2 == None: return root1

        # 中
        # 修改tree1的结构
        root1.val += root2.val

        # 左
        root1.left = self.mergeTrees(root1.left, root2.left)

        # 右
        root1.right = self.mergeTrees(root1.right, root2.right)

        return root1

递归，重新定义一个树

class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        # 终止条件
        if root1 == None: return root2  # 如果root1为空，返回root2
        if root2 == None: return root1

        # 中
        # 重新定义一个树
        root = TreeNode()
        root.val = root1.val + root2.val

        # 左
        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
from queue import Queue
class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        que1 = Queue()
        que2 = Queue()
        if root1 == None: return root2
        if root2 == None: return root1

        que1.put(root1)
        que2.put(root2)
        while not que1.empty() and not que2.empty():
            node1 = que1.get()
            node2 = que2.get()

            # 此时两个节点一定不为空，val相加
            node1.val += node2.val

            # 如果两棵树左节点都不为空，加入队列
            if node1.left and node2.left:
                que1.put(node1.left)
                que2.put(node2.left)
            # 如果两棵树右节点都不为空，加入队列
            if node1.right and node2.right:
                que1.put(node1.right)
                que2.put(node2.right)

            # 当t1的左节点 为空 t2左节点不为空，就赋值过去
            if node1.left == None and node2.left != None:
                node1.left = node2.left

            # 当t1的右节点 为空 t2右节点不为空，就赋值过去
            if node1.right == None and node2.right != None:
                node1.right = node2.right

        return root1

700. Search in a Binary Search Tree

递归

单层递归中记得要写return，或者用一个变量接住返回值。

# 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 root == None 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)

迭代

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

        return None

98. Validate Binary Search Tree

中序遍历，通过数组判断

如果是有效的二叉搜索树，中序遍历的结果应该是递增的，且没有重复

# 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:

        def inorderTraversal(node):
            if node == None:
                return
            inorderTraversal(node.left)
            sequence.append(node.val)
            inorderTraversal(node.right)

        sequence = []
        inorderTraversal(root)

        if sequence == sorted(list(set(sequence))):
            return True
        return False

直接递归

# 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:

        maxVal = float('-inf')

        def isVaild(node):
            nonlocal maxVal

            if node == None:
                return True

            is_left_valid = isVaild(node.left)  # 左

            if node.val > maxVal:               # 中
                maxVal = node.val
            else:
                return False

            is_right_vaild = isVaild(node.right) # 右
            
            return is_left_valid and is_right_vaild

        return isVaild(root)