LeetCode刷题——树（python语言）

最新推荐文章于 2024-04-28 22:58:29 发布
最新推荐文章于 2024-04-28 22:58:29 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： leetcode python 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26274961/article/details/123087264
版权

LeetCode刷题——树（python语言）

一、树

数其实就是链表的拓展，将链表的后指针的一个跟改为多个。树已经不是线性结构了。其中最为经典的就是二叉树。如下图所示，即为一个二叉树。其中1为根节点，2为左子树，3为右子树。遍历树的方法与图类似，有深度优先搜索（DFS），利用栈来存储节点（后进先出），和广度优先搜索（BFS），利用队列来存储节点（先进先出）。二叉树的遍历方法最经典有三种，分为先序（根左右），中序（左根右）和后序（左右根），遍历主要采用递归的方法，一颗子树一般遍历结束回溯。
在这里插入图片描述

二、刷题

2.1 二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

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

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。
解法一：利用DFS（深度优先搜索），每次向下遍历，深度加一。

  1. 设置变量temp记录当前节点深度
  2. 将temp作为DFS函数参数传递到子节点
  3. 程序第一次“进入”节点后更新temp
  4. “进入”空节点时说明完成一条路径的遍历，更新结果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],temp:int,ans:int):
        if not root:
            self.ans = max(temp,self.ans)
            return
        temp = temp + 1 
        self.DFS(root.left,temp,self.ans)
        self.DFS(root.right,temp,self.ans)
        return 
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        self.ans = 0
        temp = 0
        self.DFS(root,temp,self.ans)
        return self.ans

解法二：DFS后序遍历，遍历左右结点后，加上根节点的深度，以此递归

  1. 程序遇到空节点时，返回空节点的高度0给父节点
  2. 程序第三次“进入”节点时，其两个子节点的最大高度都已计算出来并返回给了该节点
  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]):
        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

解法三：BFS(广度优先搜索），每遍历一层，深度加一

# 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(root and len(q)):
            ans += 1 
            size = len(q)
            for i in range(size):
                cur = q.pop(0)
                if cur.left:
                    q.append(cur.left)
                if cur.right:
                    q.append(cur.right)
        return ans

2.2 将有序数组转换为二叉搜索树

给你一个整数数组 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],low:int,high:int):
        if low>high:
            return None
        mid = (low+high)//2
        root = TreeNode(nums[mid])
        root.left = self.buildBST(nums,low,mid-1)
        root.right = self.buildBST(nums,mid+1,high)
        return root
        
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        low,high = 0,len(nums)-1 
        return self.buildBST(nums,low,high)

2.3 二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：2
在这里插入图片描述

示例 2：
输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

提示：
树中节点数的范围在 [0, 105] 内
-1000 <= Node.val <= 1000
DFS:
首先可以想到使用深度优先搜索的方法，遍历整棵树，记录最小深度。
对于每一个非叶子节点，我们只需要分别计算其左右子树的最小叶子节点深度。这样就将一个大问题转化为了小问题，可以递归地解决该问题。

# 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 minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        
        if not root.left and not root.right:
            return 1
        
        min_depth = 10**9
        if root.left:
            min_depth = min(self.minDepth(root.left), min_depth)
        if root.right:
            min_depth = min(self.minDepth(root.right), min_depth)
        
        return min_depth + 1
#476 ms	55.7 MB

同样，我们可以想到使用广度优先搜索的方法，遍历整棵树。
当我们找到一个叶子节点时，直接返回这个叶子节点的深度。广度优先搜索的性质保证了最先搜索到的叶子节点的深度一定最小。

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0

        que = collections.deque([(root, 1)])
        while que:
            node, depth = que.popleft()
            if not node.left and not node.right:
                return depth
            if node.left:
                que.append((node.left, depth + 1))
            if node.right:
                que.append((node.right, depth + 1))
        
        return 0

#384 ms	51.8 MB
作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/solution/er-cha-shu-de-zui-xiao-shen-du-by-leetcode-solutio/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2.4 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。
叶子节点 是指没有子节点的节点。

示例 1：
输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。
在这里插入图片描述

示例 2：
输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。
在这里插入图片描述

示例 3：
输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：
树中节点的数目在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000
DFS

# 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 hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root:
            return False 
        
        s = [(root, root.val)] # elem: (node, node.val)
        while s:
            node, valSum = s.pop()
            if not node.left and not node.right:
                if valSum == targetSum:
                    return True
                continue
            if node.left:
                s.append((node.left, node.left.val + valSum))
            if node.right:
                s.append((node.right, node.right.val + valSum))
        return False

BFS

class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if not root:
            return False
        que_node = collections.deque([root])
        que_val = collections.deque([root.val])
        while que_node:
            now = que_node.popleft()
            temp = que_val.popleft()
            if not now.left and not now.right:
                if temp == sum:
                    return True
                continue
            if now.left:
                que_node.append(now.left)
                que_val.append(now.left.val + temp)
            if now.right:
                que_node.append(now.right)
                que_val.append(now.right.val + temp)
        return False

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/path-sum/solution/lu-jing-zong-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

递归
观察要求我们完成的函数，我们可以归纳出它的功能：询问是否存在从当前节点 root 到叶子节点的路径，满足其路径和为 sum。

假定从根节点到当前节点的值之和为 val，我们可以将这个大问题转化为一个小问题：是否存在从当前节点的子节点到叶子的路径，满足其路径和为 sum - val。

不难发现这满足递归的性质，若当前节点就是叶子节点，那么我们直接判断 sum 是否等于 val 即可（因为路径和已经确定，就是当前节点的值，我们只需要判断该路径和是否满足条件）。若当前节点不是叶子节点，我们只需要递归地询问它的子节点是否能满足条件即可。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/path-sum/solution/lu-jing-zong-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

# 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 hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if not root:
            return False
        if not root.left and not root.right:
            return sum == root.val
        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)

2.5 二叉搜索树迭代器

实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：
BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。
int next()将指针向右移动，然后返回指针处的数字。
注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。
你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。

示例：
在这里插入图片描述

输入
[“BSTIterator”, “next”, “next”, “hasNext”, “next”, “hasNext”, “next”, “hasNext”, “next”, “hasNext”]
[[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
输出
[null, 3, 7, true, 9, true, 15, true, 20, false]

解释
BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
bSTIterator.next(); // 返回 3
bSTIterator.next(); // 返回 7
bSTIterator.hasNext(); // 返回 True
bSTIterator.next(); // 返回 9
bSTIterator.hasNext(); // 返回 True
bSTIterator.next(); // 返回 15
bSTIterator.hasNext(); // 返回 True
bSTIterator.next(); // 返回 20
bSTIterator.hasNext(); // 返回 False

提示：

树中节点的数目在范围 [1, 105] 内
0 <= Node.val <= 106
最多调用 105 次 hasNext 和 next 操作

进阶：

你可以设计一个满足下述条件的解决方案吗？next() 和 hasNext() 操作均摊时间复杂度为 O(1) ，并使用 O(h) 内存。其中 h 是树的高度。
采用栈来存储元素。利用栈的后进先出的特性，实现DFS。对于二叉树，先让根节点入栈，将根节点的左子树都入栈，向右遍历。弹出当前节点，然后遍历右子树。

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

    def __init__(self, root: TreeNode):
        self.stack = []
        while(root):
            self.stack.append(root)
            root = root.left

    def next(self) -> int:
        cur = self.stack.pop()
        node = cur.right
        while(node):
            self.stack.append(node)
            node = node.left
        return cur.val


    def hasNext(self) -> bool:
        return len(self.stack)>0


# Your BSTIterator object will be instantiated and called as such:
# obj = BSTIterator(root)
# param_1 = obj.next()
# param_2 = obj.hasNext()
啥都不懂的小程序猿
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode 常见二叉树问题 （python实现）
weixin_46391502的博客
06-03 744
递归 树是一种常用递归操作的数据结构。一棵树要么是空，要么有两个指针，指向另外两棵树。 1. 树的高度 Leet Code 104. Maximun Depth of Binary Tree (Easy) # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.
LeetCode #101. 对称二叉树
张楚明的博客
08-08 282
LeetCode #101. 对称二叉树
python 二叉树总结(一)
weixin_45548695的博客
04-10 2276
python 二叉树总结（一）
LeetCode刷题小技巧（Python版）_“ optional[treenode]” “ treenode
最新发布
2401_84584338的博客
04-28 93
【代码】LeetCode刷题小技巧（Python版）_“ optional[treenode]” “ treenode。
【LeetCode】655. 输出二叉树
passnight的博客
08-22 306
【LeetCode】655. 输出二叉树题解
树Tree【代码笔记】
PrototypeOne的博客
12-29 977
树是n（n>=0）个结点的有限集。当n = 0时，称为空树。显然，树的定义是递归的，即在树的定义中又用到了自身，树是一种递归的数据结构。因此n个结点的树中有n-1条边。
树的概念及其应用（Python）
迪文的博客
06-24 935
树是一种由节点（node）和边（edges）构成层级关系的结构。如果你了解 linux 文件结构（tree 命令），它的结构也是一棵树。我们快速看下树涉及到的一些概念：二叉树是树结构里面最常用的一种树结构，其实二叉树就是一种简单的树。二叉树的每个节点最多包含两个孩子。从上边的图来看几个二叉树的概念：一棵 size 为 n 的二叉树高度最多可以是 n，最小的高度是 ⌊lgn⌋+1，这里 log 以 2 为底简写为 lgn。一棵二叉树的前序遍历结果 = 根节点 + 左子树的前序遍历结果 + 右子树的前序遍历结果
LeetCode (python实现) —— 树
HachiLin的博客
01-13 400
1. 难度：简单 104：二叉树的最大深度 题目描述 给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 例子 给定二叉树 [3,9,20,null,null,15,7]    3   /   \  9    20    /   \    15   7 返回它的最大深度3 ...
Leetcode刷题笔记（C++）——二叉树
CV小菜鸟的博客
08-01 337
Leetcode刷题笔记（C++）——二叉树 整理一下刷题过程中的思路，在这里进行一下总结与分享。 github地址：https://github.com/lvjian0706/Leetcode-solutions github项目是刚刚新建的，陆续会将整理的代码以及思路上传上去，代码是基于C++与python的。同时会将基础的排序算法等也一并进行整理上传。 102. 二叉树的层序遍历 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,2
leetcode2-LeetCode_Python3:Leetcode算法刷题——Python3
06-29
Leetcode刷题笔记整理——Python3 By Xyao 本人从2020/04/25开始正式在LeetCode上刷题，于2020/07/04完整刷完一遍剑指offer系列，边刷题边整理笔记。（此处特别感谢LeetCode解题区及评论区的大佬们提供的一些优质...
LeetCode刷题——Complex multiplication复数乘法
12-21
在LeetCode刷题的过程中，我们经常会遇到各种类型的挑战，其中包括涉及数学和字符串处理的问题。"Complex multiplication"（复数乘法）就是一个典型的例子，它将基础的数学概念与编程技巧结合在一起，要求我们理解...
LeetCode刷题——91. 解码方法
12-20
【LeetCode刷题——91. 解码方法】 这道编程题目来自LeetCode，主要考察的是动态规划和递归解题技巧。问题的核心是给定一个仅由数字组成的非空字符串，我们需要计算出该字符串有多少种不同的解码方法，这里的解码是...
LeetCode刷题——62. 不同路径
12-20
【LeetCode刷题——62. 不同路径】这道题目是经典的动态规划问题，主要考察的是算法设计和实现能力。题目描述了一个机器人在m x n的网格中，从左上角开始，每次只能向下或向右移动一步，目标是到达右下角。求解从...
LeetCode刷题——Valid square有效正方形
12-20
在LeetCode刷题的过程中，我们经常会遇到各种类型的题目，其中之一就是"Valid Square"（有效正方形）。这道问题属于算法领域，特别是数学和几何部分，它要求我们判断四个给定点是否能构成一个正方形。虽然它被标记为...
LeetCode刷题小技巧（Python版）_“ optional[treenode]” “ treenode(1)
2301_76379671的博客
04-17 622
(set([‘b’, ‘r’, ‘u’, ‘o’, ‘n’]), set([‘e’, ‘o’, ‘g’, ‘l’])) # 重复的被删除。x & y # 交集。x | y # 并集。x - y # 差集。
Python数据结构与算法篇（十二）-- 树和二叉树
CarpeDiem
03-19 1951
终于学到了二叉树，LeetCode里面三分之一都是关于二叉树，俗话说打铁还需自身硬，本节学习树的基本概念，二叉树的实现、遍历、转换二叉树等。
[python刷题模板] 树的直径/换根DP
liuliangcan的博客
01-22 1771
py刷题模板之树的直径/换根DP
Python篇——数据结构与算法（第七部分：树）
qq_42120059的博客
06-19 239
【代码】Python篇——数据结构与算法（第七部分：树）
【Leetcode 常见报错】
weixin_44779122的博客
06-28 211
原因：自己提交的代码修改了原有的类名。
leetcode刷题路线python
10-07
leetcode刷题路线python可以根据不同的目标和程度划分为初级、中级和高级阶段。在初级阶段，可以着重练习基础的算法和数据结构，例如数组、链表、栈、队列、哈希表等。在中级阶段，可以深入学习动态规划、贪心算法、回溯算法等高级算法，并通过刷题来加深理解。在高级阶段，可以关注一些高级主题，例如图论、位运算、并查集等。此外，还可以学习一些常用的技巧和优化方法，例如双指针法、滑动窗口法、二分查找等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值