2021-07-13:二叉树1

最新推荐文章于 2022-08-10 15:42:14 发布
最新推荐文章于 2022-08-10 15:42:14 发布
阅读量126 收藏
点赞数
文章标签： python leetcode 二叉树 数据结构 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41179957/article/details/118697483
版权

二叉树题目：

# 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: TreeNode) -> int:
        if not root:return 0
        return max(self.maxDepthhelper(root.left,1),self.maxDepthhelper(root.right,1))
    def maxDepthhelper(self,node,d):
        if node:
            return max(self.maxDepthhelper(node.left,d+1),self.maxDepthhelper(node.right,d+1))
        return d

更简便：

# 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: TreeNode) -> int:
        if not root:return 0
        return max(self.maxDepth(root.left),self.maxDepth(root.right))+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 isBalanced(self, root: TreeNode) -> bool:
        self.result = True
        self.maxdepth(root)
        return self.result
    def maxdepth(self,root):
        if not root: return 0
        l = self.maxdepth(root.left)
        r = self.maxdepth(root.right)
        if abs(l-r)>1: 
            self.result = False
        return 1 +max(l,r)
# 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 isBalanced(self, root: TreeNode) -> bool:
        return self.maxdepth(root) != -1
        return self.result
    def maxdepth(self,root):
        if not root: return 0
        l = self.maxdepth(root.left)
        if l == -1: return -1
        r = self.maxdepth(root.right)
        if r == -1: return -1
        return max(l,r)+1 if abs(l-r)<=1 else -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 diameterOfBinaryTree(self, root: TreeNode) -> int:
    # 3个变量，左边深度，右边深度，本层的路径长度最大值
        if not root: return 0
        self.maxd = 0
        self.maxdepth(root)
        return self.maxd
    def maxdepth(self,root):
        if not root:
            return 0
        l = self.maxdepth(root.left)
        r = self.maxdepth(root.right)
        self.maxd = max(self.maxd,l+r)
        return max(l,r)+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 invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return
        self.switchtree(root)
        return root
    def switchtree(self,root):
        switchnode = root.right
        root.right = root.left
        root.left = switchnode
        self.invertTree(root.right)
        self.invertTree(root.left)

问题代码：

# 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: TreeNode, root2: TreeNode) -> TreeNode:
        root3 = TreeNode(0)
        self.mergehelper(root1,root2,root3)
        return root3
    def mergehelper(self,root1,root2,root3):
        if not root1 and root2:
            return
        elif not root1:
            root3 = root2
        elif not root2:
            root3 = root1
        else:
            root3 = TreeNode(root1.val+root2.val)
            self.mergehelper(root1.left,root2.left,root3.left)
            self.mergehelper(root1.right,root2.right,root3.right)

问题：必须要存在这个节点，不能指向None之后给他赋值

循环用函数的套路：

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 mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
        if not root1 and not root2:
            return None
        elif not root1:
            return root2
        elif not root2:
            return root1
        else:
            root3 = TreeNode(root1.val+root2.val)
            root3.left = self.mergeTrees(root1.left,root2.left)
            root3.right = self.mergeTrees(root1.right,root2.right)
            return root3


# 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, targetSum: int) -> bool:
        if not root:
            return False
        self.result = False
        self.sumhelper(root,targetSum,root.val)
        return self.result
    def sumhelper(self,root,targetSum,sum1):
        if not root.left and not root.right:
            if sum1 == targetSum:
                self.result = True 
        if root.left: 
            self.sumhelper(root.left,targetSum,sum1+root.left.val)
        if root.right:
            self.sumhelper(root.right,targetSum,sum1+root.right.val)

如果不调用新的函数的话，那么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 hasPathSum(self, root: TreeNode, targetSum: int) -> bool:
        if not root:
            return False
        if not root.left and not root.right:
            return targetSum == root.val
        return self.hasPathSum(root.left,targetSum-root.val) or self.hasPathSum(root.right,targetSum-root.val)

思路， 用一个list去存 进入递归的这个点到它不同的父节点的所有不同的值，然后判断sum是不是等于这个list里面的值，是的话加一

方法1：

class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> int:
        self.sum = sum
        self.count = 0
        self.dfs(root,[])
        return self.count
    def dfs(self,root, sumlist):
        if root is None:
            return 0
        
        sumlist = [num+root.val for num in sumlist]
        sumlist.append(root.val)
        
        for num in sumlist:
            if num == self.sum:
                self.count += 1
        # count = sumlist.count(sum)
        self.dfs(root.left,sumlist)
        self.dfs(root.right, sumlist)

return的值要的就是计算出来的路径数量总和 

dfs是O(n)的复杂度，子节点的深度平均O(logn)的话，数组生产的复杂度是O(logn)。总的时间复杂度就是O(nlogn)把

时间，O(N)

空间复杂度O(N^2)

方法2：

class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> int:
        self.sum = sum
        return self.dfs(root,[])
    def dfs(self,root, sumlist):
        if root is None:
            return 0
        
        sumlist = [num+root.val for num in sumlist]
        sumlist.append(root.val)
        
        count = 0
        for num in sumlist:
            if num == self.sum:
                count += 1
        # count = sumlist.count(sum)

        return count + self.dfs(root.left, sumlist) + self.dfs(root.right, sumlist)

思路：用主函数去回溯主树的子树

一个函数去判断子树是不是和给的树相等

# 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 isSubtree(self, root: TreeNode, subRoot: TreeNode) -> bool:
        """
        :type s: TreeNode
        :type t: TreeNode
        :rtype: bool
        """
        if not root and not subRoot:
            return True
        if not root or not subRoot:
            return False
        return self.isSametree(root,subRoot) or self.isSubtree(root.left,subRoot) or self.isSubtree(root.right,subRoot)
    def isSametree(self,s,t):
        if not s and not t:
            return True
        if not s or not t:
            return False
        return s.val == t.val and self.isSametree(s.left,t.left) and self.isSametree(s.right,t.right)

 

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

Pre-order 前序：根左右

In-order  中序： 左根右

Post-order 后序：左右根

注意叶子节点的定义：

 叶子左右都没有子节点

# 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:
        self.depth = 100000
        if not root:
            return 0
        return self.minDepthhelper(root,1)
    def minDepthhelper(self,root,depth):
        if not root.left and not root.right:
            self.depth = depth
            return depth
        if depth > self.depth:
            return depth
        if not root.left:
            return self.minDepthhelper(root.right,depth+1)
        if not root.right:
            return self.minDepthhelper(root.left,depth+1)
        return min(self.minDepthhelper(root.left,depth+1),self.minDepthhelper(root.right,depth+1))

每次计算的时候一定要自己想例子按照代码肉眼debug一遍

# 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 sumOfLeftLeaves(self, root: TreeNode) -> int:
        if not root:
            return 0
        if root.left:
            if not root.left.left and not root.left.right:
                return root.left.val + self.sumOfLeftLeaves(root.right)
        return self.sumOfLeftLeaves(root.right) + self.sumOfLeftLeaves(root.left)

问题代码： 

# 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 longestUnivaluePath(self, root: TreeNode) -> int:
        self.ans = 0
        self.maxrootpath(root)
        return self.ans
    def maxrootpath(self,root):
        if not root:
            return 
        left = self.maxrootpath(root.left)
        right = self.maxrootpath(root.right)
        left += 1 if root.left and root.left.val == root.val else 0
        right += 1 if root.right and root.right.val == root.val else 0
        self.ans = max(self.ans, left+right)
        return left+right

问题：

1.

调用maxrootpath的时候left+right是计算出的经过当前根节点的最长路径

但return的值一定是经过当前节点的最深路径

2.

left = left + 1 if root.left and root.left.val == root.val else 0
right = right + 1 if root.right and root.right.val == root.val else 0

如果值不相等的话是直接置0

正确代码：

# 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 longestUnivaluePath(self, root: TreeNode) -> int:
        self.ans = 0
        self.maxrootpath(root)
        return self.ans
    def maxrootpath(self,root):
        if not root:
            return 0
        left = self.maxrootpath(root.left)
        right = self.maxrootpath(root.right)
        left = left + 1 if root.left and root.left.val == root.val else 0
        right = right + 1 if root.right and root.right.val == root.val else 0
        self.ans = max(self.ans, left+right)
        return max(left,right)

 动态规划+二叉树

# 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 rob(self, root: TreeNode) -> int:
        #动态规划，从下到上：
        return max(self.robhelp(root))

    def robhelp(self,root):
        if not root: return 0,0 #偷，不偷
        left = self.robhelp(root.left)
        right = self.robhelp(root.right)
        #偷当前节点，则子节点不能偷
        v1 = root.val + left[1]+right[1]
        #不偷当前节点，则取左右子树偷与不偷算下来的最大值加起来
        v2 = max(left)+max(right)
        return v1,v2

用一个set去存储值。

去掉最小值，剩下的那个就是第二小值 

# 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
import heapq
class Solution:
    def findSecondMinimumValue(self, root: TreeNode) -> int:
        self.res = set()
        if not root:
            return -1
        self.helper(root)
        if len(self.res) < 2:
            return -1
        self.res.remove(min(self.res))
        return min(self.res)
    def helper(self,root):
        if len(self.res) > 3:
            return
        if not root:
            return
        self.res.add(root.val)
        self.helper(root.left)
        self.helper(root.right)



# 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 averageOfLevels(self, root: TreeNode) -> List[float]:
        self.sum = []
        self.count = []
        self.addlevel(root,0)
        for i in range(len(self.sum)):
            self.sum[i] = self.sum[i]/self.count[i]
        return self.sum

    def addlevel(self,pnode,level):
        if not pnode:
            return
        if level < len(self.sum):
            self.sum[level] += pnode.val
            self.count[level] += 1
        else:
            self.sum.append(pnode.val)
            self.count.append(1)
        self.addlevel(pnode.left,level+1)
        self.addlevel(pnode.right,level+1)

qq_41179957
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
leetcodetreenode-binary-tree-inorder-traversal:二叉树中序遍历
07-01
二叉树中序遍历 :evergreen_tree: 给定一棵二叉树，返回其节点值的中序遍历。 Example: Input: [1,null,2,3] 1 \ 2 / 3 Output: [1,3,2] 跟进：递归解决方案是微不足道的，你能迭代吗？ 中序遍历： 请注意，节点 75 ...
（LeetCode）二叉树
BrownWong的专栏
06-21 2735
1. 合并二叉树 617. merge-two-binary-trees # Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution(object): def mergeTrees(sel
【算法笔记】二叉树应用
computs的博客
02-11 624
226. 翻转二叉树 解1 这其实也是层序遍历的应用，遍历每一层是先交换结点的左右孩子，然后将非空的左右结点入队。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * Tr
力扣(LeetCode)刷题，简单题(第3期)
不脱发的程序猿
02-16 4623
力扣(LeetCode)定期刷题，每期10道题，业务繁重的同志可以看看我分享的思路，不是最高效解决方案，只求互相提升。 第1题：相同的树 试题要求如下： 回答（C语言）： /** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *lef...
二叉树 | 层序遍历 | leecode刷题笔记
qq_44250700的博客
08-10 304
跟随carl代码随想录刷题 语言：python 👍carl哥太牛了！！！
二叉树最大宽度
qq_45443879的博客
03-07 368
给定一个二叉树，编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与满二叉树（full binary tree）结构相同，但一些节点为空。 每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的null节点也计入长度）之间的长度。 输入: 1 / \ 3 2 / \ ...
leetcodetreenode-binary-tree-paths:二叉树路径
07-01
树节点二叉树路径 给定一棵二叉树，返回所有从根到叶的路径。 注意：叶子是没有子节点的节点。 Example: Input: 1 / \ 2 3 \ 5 Output: ["1->2->5", "1->3"] Explanation: All root-to-leaf paths are: 1->2->5, 1->...
leetcodetreenode-morris-inorder-traversal:二叉树的莫里斯中序遍历
07-01
给定一棵二叉树，返回其节点值的中序遍历。 Example: Input: [1,null,2,3] 1 \ 2 / 3 Output: [1,3,2] :red_exclamation_mark: :collision: 注意：在不使用递归（隐式使用堆栈）或显式堆栈的情况下实现中序遍历。 :...
react-binary-tree：二叉树遍历可视化
02-05
二叉树遍历可视化器 该项目是一个二叉树遍历可视化工具。 观看。 支持的遍历： 1. Level Order Traversal 2. Depth First Traversal(Pre-order,Post-order,In-order) 您可以在此处了解有关这些算法的更多信息： ...
leetcodetreenode-diameter-of-binary-tree:二叉树直径
07-01
树节点二叉树的直径 给定一棵二叉树，您需要计算树的直径长度。 二叉树的直径是树中任意两个节点之间最长路径的长度。 此路径可能会或可能不会通过根。 Example: Given a binary tree 1 / \ 2 3 / \ 4 5 Return 3, ...
代码随想录刷题记录：二叉树篇（第二部分）
qq_53324833的博客
02-06 515
236. 二叉树的最近公共祖先 题目描述： 思路分析： 反正我现在对递归都还很懵…多练叭只能是。卡尔大佬的思路还是能看懂的，就是自己做的时候实在是想不到。 代码如下： /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * }
力扣(LeetCode)刷题，简单题(第13期)
不脱发的程序猿
05-29 3026
力扣(LeetCode)定期刷题，每期10道题，业务繁重的同志可以看看我分享的思路，不是最高效解决方案，只求互相提升。 第1题：字符的最短距离 试题要求如下： 解答思路： 从左向右遍历，记录上一个字符 C 出现的位置 prev，那么答案就是 i - prev。 从右想做遍历，记录上一个字符 C 出现的位置 prev，那么答案就是 prev - i。 这两个值取最小就是答案。 回答（C语言）： /** * Note: The returned array must be malloce
力扣---2020.8.16
Carroll的博客
11-04 164
733. 图像渲染 class Solution { public int[][] floodFill(int[][] image, int sr, int sc, int newColor) { return dfs(image, sr, sc, newColor, image[sr][sc]); } public int[][] dfs(int[][] image, int i, int j, int newColor, int num){ if
数据结构与算法分析：（十四） 二叉树
riemann_的博客
04-14 732
一、前言 前面我们讲了都是线性表结构，比如：数组、链表、栈、队列等。今天我们终于可以讲一讲树了，树是非线性结构。 我们都知道，对于大量的输入数据，链表的线性访问太慢，不宜使用。我们今天讲的树，其大部分操作的运行时间平均为 O(log⁡n\log nlogn)。 讲二叉树之前我们先来思考一下这几个问题。二叉树有哪几种存储方式？什么样的二叉树适合用数组来存储？带着问题与思考，看完以后顿时会对二叉树的设...
leetcode 671 二叉树中第二小的节点/** * Definition for a binary tree node. * public class TreeNode { * i
起飞芜湖的博客
02-09 278
思路：首先看题，求第二小值，而且根节点不会大于孩子节点的值，（由于这种特性，尤其要分析节点全是跟root值一样的树） 采用递归:如果左右子树的第二小节点都是和root 相等，则返回-1，否则，当二者都不等于-1，返回两者之小；若有其中一方等于root则返回另一个。 class Solution { public int findSecondMinimumValue(TreeNode...
binary tree | 层次遍历相关
东南风的博客
07-20 233
一、层次遍历 题目： 102. Binary Tree Level Order Traversal Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level). For example: Given binary tr...
leetcode 平衡高度二叉树/** * Definition for a binary tree node. * public class TreeNode { * int val;
起飞芜湖的博客
02-06 564
思路：前提会 计算二叉树最大深度（在计算二叉树最大深度的时候，就是采用递归的方法，取左右子树的最大）； 所以稍加改造，在每次计算左右子树的最大深度之后，加一个if ,判断是否满足，绝对值之差不超过1，如果不满足，就赋值给一个flag private boolean result = true; public boolean isBalanced(TreeNode root) { m...
[LeetCode] Binary Tree Paths - 二叉树基础系列题目
weixin_33910137的博客
09-09 182
目录：1.Binary Tree Paths - 求二叉树路径 2.Same Tree - 判断二叉树相等 3.Symmetric Tree - 判断二叉树对称镜像 Binary Tree Paths 题目概述：Given a binary tree, return all root-to-leaf paths. For exam...
leetcode二叉树路径相关题目
qq_38887077的博客
07-09 123
路径总和 class Solution: def hasPathSum(self, root: TreeNode, target: int) -> bool: # 递归 if not root: return False if not root.left and not root.right and target == root.val: return True return False or self.hasPathSum(root.
软件技术基础-树结构(与“二叉树”有关文档共77张).pptx
最新发布
11-14
此外，二叉树还有多种变体，如完全二叉树（所有层级都尽可能填满，除了最后一层外），满二叉树（所有节点要么是叶子节点，要么有两个子节点），以及平衡二叉树（左右子树高度差不超过1，确保搜索效率）。 树结构和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值