Leedcode 第九天构建合并搜索二叉树5 python

最新推荐文章于 2024-08-23 16:53:34 发布

又南又难

最新推荐文章于 2024-08-23 16:53:34 发布

阅读量135

点赞数

分类专栏： Leetcode 文章标签： python leetcode 算法

本文链接：https://blog.csdn.net/m0_43424109/article/details/129916276

版权

Leetcode 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

文章提供了一系列关于二叉树的题目，包括根据遍历序列构造二叉树、在二叉搜索树中搜索特定值、验证二叉搜索树的有效性、找到二叉搜索树中最小的绝对差以及找出二叉搜索树中的众数。这些问题都涉及到递归遍历和二叉树结构的理解与操作。

摘要由CSDN通过智能技术生成

以下题目来源LeetCode

106. 从中序与后序遍历序列构造二叉树
给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗二叉树。

# 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 buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
      
        def traversal(inorder,postorder):
            if(len(postorder)==0): #如果数组大小为零的话，说明是空节点
                return None
            rootvalue=postorder[-1] #如果不为零，取后序数组最后一个节点作为节点元素
            root=TreeNode(rootvalue) 
            if (len(postorder)==1):
                return root
            
            delimiterIndex=inorder.index(rootvalue) #找到后序数组中最后一位元素在中序数组中的位置，以此作为切割点
            leftinorder=inorder[0:delimiterIndex] #对中序数组进行左右子树切割
            rightinorder=inorder[delimiterIndex+1:]
            postorder.pop() #
            leftPost=postorder[0:len(leftinorder)]#对后序数组进行左右子树切割
            rightpost=postorder[len(leftinorder):]

            root.left=traversal(leftinorder,leftPost) #递归遍历
            root.right=traversal(rightinorder,rightpost)
            return root
        if(len(inorder)==0 or len(postorder)==0):
            return None
        return traversal(inorder,postorder)

105. 从前序与中序遍历序列构造二叉树
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

# 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 buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        def traversal(preorder,inorder):
            if len(preorder)==0:
                return None
            rootvalue=preorder[0]
            root=TreeNode(rootvalue)
            if len(preorder)==1:
                return root
            
            delimiterIndex=inorder.index(rootvalue)
            leftInorder=inorder[0:delimiterIndex]
            rightInorder=inorder[delimiterIndex+1:]

            preorder.pop(0)
            leftPreorder=preorder[0:len(leftInorder)]
            rightPreorder=preorder[len(leftInorder):]

            root.left=traversal(leftPreorder,leftInorder)
            root.right=traversal(rightPreorder,rightInorder)

            return root
        return traversal(preorder,inorder)

654. 最大二叉树
给定一个不重复的整数数组 nums 。最大二叉树可以用下面的算法从 nums 递归地构建:

创建一个根节点，其值为 nums 中的最大值。
递归地在最大值左边的子数组前缀上构建左子树。
递归地在最大值右边的子数组后缀上构建右子树。
返回 nums 构建的最大二叉树。

# 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])
        
        maxvalue=max(nums)
        maxindex=nums.index(maxvalue)
        root=root=TreeNode(maxvalue)

        if maxindex>0:
            root.left=self.constructMaximumBinaryTree(nums[0:maxindex])
        if maxindex<len(nums)-1:
            root.right=self.constructMaximumBinaryTree(nums[maxindex+1:])
        return root

617. 合并二叉树
给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

# 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 and root2==None:
            return None
        elif root1==None and root2!=None:
            return root2
        elif root1!=None and root2==None:
            return root1

        root= TreeNode(root1.val+root2.val)
        left_=self.mergeTrees(root1.left,root2.left)
        right_=self.mergeTrees(root1.right,root2.right)
        root.left=left_
        root.right=right_
        return root

700. 二叉搜索树中的搜索
给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。返回以该节点为根的子树。如果节点不存在，则返回 null 。

# 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:
            return None
        if root.val==val:
            return root
        node_left=self.searchBST( root.left, val)
        node_right=self.searchBST( root.right, val)
        if node_left:
            return node_left
        elif node_right:
            return node_right
        else:
            return None

98. 验证二叉搜索树
给你一个二叉树的根节点 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 isValidBST(self, root: Optional[TreeNode]) -> bool:
        path=[]
        def traversal(root):
            if root==None:
                return
            traversal(root.left)
            path.append(root.val)
            traversal(root.right)
        traversal(root)
        for i in range(0,len(path)-1):
            if path[i]>=path[i+1]:
                return False
        return True

530. 二叉搜索树的最小绝对差
给你一个二叉搜索树的根节点 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 getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        path=[]
        def traversal(root):
            if root==None:
                return 
            traversal(root.left)
            path.append(root.val)
            traversal(root.right)
        traversal(root)
        res=100000
        for i in range(len(path)-1):
            res=min(res,path[i+1]-path[i])
        return res

501. 二叉搜索树中的众数
给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按任意顺序返回。

假定 BST 满足如下定义：

结点左子树中所含节点的值小于等于当前节点的值
结点右子树中所含节点的值大于等于当前节点的值
左子树和右子树都是二叉搜索树

# 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 findMode(self, root: Optional[TreeNode]) -> List[int]:
        path=[]
        def traversal(root):
            if root==None:
                return 
            traversal(root.left)
            path.append(root.val)
            traversal(root.right)
        if root.left==None and root.right==None:
            return [root.val]
        traversal(root)
        dict_={}
        for i in path:
            if i not in dict_:
                dict_[i]=1
            else:
                dict_[i]=dict_[i]+1
        dict_=sorted(dict_.items(),key=lambda e:e[1], reverse=True )
        res=[dict_[0][0]]
    
        for i in range(1,len(dict_)):
            if dict_[i][1]==dict_[0][1]:
                res.append(dict_[i][0])
            else:
                break
        return res