leetcode基础编程：树

最新推荐文章于 2024-09-05 16:52:50 发布

irrationality

最新推荐文章于 2024-09-05 16:52:50 发布

阅读量350

点赞数

分类专栏： leetcode 文章标签： leetcode 深度优先算法树数据结构

本文链接：https://blog.csdn.net/weixin_54227557/article/details/123099924

版权

leetcode 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

这篇博客介绍了两种解决二叉树问题的方法：计算最大深度和将有序数组转换为高度平衡的二叉搜索树。对于最大深度，通过深度优先搜索（DFS）和广度优先搜索（BFS）实现。有序数组转换问题，通过递归构建平衡二叉搜索树确保每个节点的左右子树高度差不超过1。

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

88. 二叉树的最大深度

难度：简单

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

/ \
9 20
/ \
15 7
返回它的最大深度 3 。

方法一

# 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 dfs(self,root:Optional[TreeNode],temp:int,ans:int):
        if not root:
            self.ans=max(self.ans,temp)
            return
        temp=temp+1
        self.dfs(root.left,temp,self.ans)
        self.dfs(root.right,temp,self.ans)
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        self.ans=0
        temp=0
        self.dfs(root,temp,self.ans)
        return self.ans

方法二

# 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 dfs(self,root:Optional[TreeNode]):
        if not root:
            return 0
        left=self.dfs(root.left)
        right=self.dfs(root.right)
        ans = max(left,right)+1
        return ans
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        
        ans=self.dfs(root)
        return ans

方法三

# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
        ans=0
        q=[]
        q.append(root)
        while len(q) and q[0]:
            ans +=1
            size=len(q)
            for i in range(len(q)):
                cur=q.pop(0)
                if cur.left:
                    q.append(cur.left)
                if cur.right:
                    q.append(cur.right)
        return ans

\92. 将有序数组转换为二叉搜索树

难度：简单

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：

输入：nums = [1,3]
输出：[3,1]
解释：[1,3] 和 [3,1] 都是高度平衡二叉搜索树。

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
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 buildBST(self,nums:List[int],lo:int,hi:int)-> TreeNode:
        if lo > hi:
            return None
        mid = int(lo+(hi-lo)/2)
        root = TreeNode(nums[mid])
        root.left= self.buildBST(nums,lo,mid-1)
        root.right = self.buildBST(nums,mid+1,hi)
        return root
        
        
    
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        lo,hi=0,len(nums)-1
        ans=self.buildBST(nums,lo,hi)
        return ans