LeetCode | Tree

已于 2022-05-07 19:05:32 修改
阅读量53 收藏
点赞数
分类专栏： LeetCode 文章标签： python
于 2022-04-27 20:20:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43521859/article/details/124443238
版权

2022-4-27

哭唧唧，昨天做的记录没有保存，算啦1-d dp再做一遍好啦当加深记忆啦！当然要记得及时保存哈！

226. Invert Binary Tree

  • 主要思路：dfs | 当前根节点的左右两个子孩子交换位置，问题就转化成了两个子孩子作为根节点的反转问题；
    • version2为version1的简化版本，本质没啥区别；
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 None
        
        # 当前节点左右子节点交换位置
        tmp = root.left
        root.left = root.right
        root.right = tmp
        
        root.left = self.invertTree(root.left)    # 左子树反转
        root.right = self.invertTree(root.right)  # 右子树反转
        return root
        
    def invertTree2(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
        return root

104. Maximum Depth of Binary Tree

  • 递归杀我千百回
  • 跟neetcode的日常
  • 主要思路：neetcode主要给出了三种解法

  1. RECURSIVE DFS：当前节点的depth = 左右孩子的最大深度 + 1 【不用担心当前节点如果是None会不会也+1了，在base case的时候已经过滤掉了None节点】

  2. ITERATIVE DFS | stack：stack存放[node, depth]；root放进去stack，pop出来，放左右节点；每次pop都更新下最大深度res；后面就是pop栈顶元素，更新res，栈顶元素左右节点和depth信息压栈，loop直到栈空了；

    头一次遇到stack可以同时存放node和depth的！是我愚钝了！[之前遇到的要么就是node要么就放index哈哈哈]
    在这里插入图片描述

  3. BFS | queue：

    1. 该层节点放进去，记录depth
    2. 队首pop出来，队尾加进去pop出来的节点的左右孩子(如果有的话)，记录depth；
    3. 重复2操作，直到queue为空；

    可能会想问为什么要用队列呢？考虑以下队列的性质，先进先出的性质比较符合bfs的逻辑；而stack的前进后出的性质比较符合dfs的逻辑；

    • depth的更新逻辑是while进去都是当前层的node在里面，for的是当前层的node，虽然append了node的左右子节点，按照逻辑来说append之后没有改变当前层的len(q)，应该是在下次进去while之后queue已经把前一层的node全pop掉了，又变成了下一层(现在的当前层)的所有node了；
      注意要处理root is None的case；
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution:
    def maxDepth_re_dfs(self, root) -> int:
        if not root:
            return 0
        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

    def maxDepth_it_dfs(self, root) -> int:
        if not root:
            return 0

        stack = [[root, 1]]
        res = 0

        while stack:
            node, depth = stack.pop()

            res = max(res, depth)
            if node.left:
                stack.append([node.left, depth + 1])
            if node.right:
                stack.append([node.right, depth + 1])
        return res

    def maxDepth_it_dfs2(self, root) -> int:
        stack = [[root, 1]]
        res = 0

        while stack:
            node, depth = stack.pop()
            if node:
                res = max(res, depth)
                stack.append([node.left, depth + 1])
                stack.append([node.right, depth + 1])
        return res


    def maxDepth_bfs(self, root) -> int:
        if not root:
            return 0

        from collections import deque
        q = deque([root])
        depth = 0

        while q:
            for _ in range(len(q)):
                node = q.popleft()
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            depth += 1
        return depth
    
    def maxDepth_bfs2(self, root) -> int:
        from collections import deque
        q = deque([root])
        depth = 0

        while q:
            for _ in range(len(q)):
                node = q.popleft()
                if node:
                    q.append(node.left)
                    q.append(node.right)
            depth += 1
        return depth - 1

ps 2.的v1和v2以及3.的v1和v2就是在处理边界的时候稍微修改了一下；目前而言感觉还是v1的比较好理解符合逻辑，v2的话空节点也会压栈，但是可以一起处理一开始根节点为空的情况；嗐，各有所长吧；

2022-5-7 重新过了一遍dfs，果然我是不会写的那么简洁的orz【我的逻辑g了哈哈哈哈】
那三句实际上可以合并成return 1+max(dfs(root.left, depth),dfs(root.right))

class Solution:
    def maxDepth(self, root):
        def dfs(root, depth):
            if not root:
                return depth
            depth += 1
            depth = max(dfs(root.left, depth), dfs(root.right, depth))
            return depth
        return dfs(root, 0)

顺便把BFS系列过一遍

BFS

102. Binary Tree Level Order Traversal

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []

        from collections import deque
        q = deque([root])
        res = []

        while q:
            tmp = []
            for _ in range(len(q)):
                node = q.popleft()
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            res.append(tmp)
        return res

107. Binary Tree Level Order Traversal II

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def levelOrderBottom(self, root: TreeNode):
        if not root:
            return []

        from collections import deque
        q = deque([root])
        res = []

        while q:
            tmp = []
            for _ in range(len(q)):
                node = q.popleft()
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            res.insert(0, tmp)
        return res

199. Binary Tree Right Side View

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution:
    def rightSideView(self, root):
        if not root:
            return []

        from collections import deque
        q = deque([root])
        res = []

        while q:
            tmp = []
            for _ in range(len(q)):
                node = q.popleft()
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            res.append(tmp[-1])
        return res

637. Average of Levels in Binary Tree

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):
        from collections import deque
        q = deque([root])
        res = []

        while q:
            tmp = []
            for _ in range(len(q)):
                node = q.popleft()
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            res.append(sum(tmp) / len(tmp))
        return res

429. N-ary Tree Level Order Traversal

class TreeNode:
    def __init__(self, val=0, children=None):
        self.val = val
        self.children = children
class Solution:
    def levelOrder(self, root):
        if not root:
            return []
        from collections import deque
        q = deque([root])
        res = []

        while q:
            tmp = []
            for _ in range(len(q)):
                node = q.popleft()
                tmp.append(node.val)
                if node.children:
                    q.extend(node.children)
            res.append(tmp)
        return res

515. Find Largest Value in Each Tree Row

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def largestValues(self, root):
        if not root:
            return []

        from collections import deque
        q = deque([root])
        res = []

        while q:
            tmp = float("-inf")
            for _ in range(len(q)):
                node = q.popleft()
                tmp = max(tmp, node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            res.append(tmp)
        return res

116. Populating Next Right Pointers in Each Node

这道题不需要存val；边连边存层；这里默认next是None所以range(len(q) - 1)就可以了；

class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next

class Solution:
    def connect(self, root):
        if not root:
            return root

        from collections import deque
        q = deque([root])

        while q:
            for i in range(len(q) - 1):
                q[i].next = q[i + 1]

            for _ in range(len(q)):
                node = q.popleft()
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
        return root

117. Populating Next Right Pointers in Each Node II

和116一样可过；

104. Maximum Depth of Binary Tree

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) -> int:
        if not root:
            return 0

        from collections import deque
        q = deque([root])
        depth = 0

        while q:
            for i in range(len(q)):
                node = q.popleft()
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            depth += 1
        return depth

111. Minimum Depth of Binary Tree

相比104：当遇到左右孩子都空时，说明该节点是其中一条路径的终点了，可以提前终止了；

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):
        if not root:
            return 0

        from collections import deque
        q = deque([root])
        depth = 0

        while q:
            depth += 1
            for _ in range(len(q)):
                node = q.popleft()
                if not node.left and not node.right:
                    return depth
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
        return depth

543. Diameter of Binary Tree

  • 思路很明显去记录下每个节点左右子树的最大深度的和，注意复用；

自己写dfs还是会卡住！！

  • 求二叉树的最大深度模块[104]就可以复用了，空节点返回-1真的绝！
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):
        res = [0]
        def dfs(root):
            if not root:
                return -1

            left = dfs(root.left)
            right = dfs(root.right)
            res[0] = max(res[0], 2+left+right)
            return 1 + max(left, right)
        dfs(root)
        return res[0]

110. Balanced Binary Tree

  • 还是复用dfs的104模块！
  • 这道题的关键在与如何保存下面节点是不是平衡的信息
    • 为了和543看起来差不多我们还是选择使用res全局变量来搞；
    • 我们要知道这是一个dfs到最后再逐步往上check的过程，也就是说如果下面有一个节点不平衡的时候res[0]的状态就改为False了，好像没法提前终止返回，所以后面就算节点是平衡的也不需要改变res[0]的状态了；状态改为false之后不管你之后平不平衡都已经无所谓了
      所以修改的条件为：
      if res[0] and (left - right > 1 or right - left > 1): res[0] = False 
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):
        res = [True]
        def dfs(root):
            if not root:
                return -1
            
            left = dfs(root.left)
            right = dfs(root.right)
            if res[0] and (left - right > 1 or  right - left > 1):
                res[0] = False
            return 1 + max(left, right)
        dfs(root)
        return res[0]

100. Same Tree

属于边dfs边check的类型，和226差不多

  • 比较节点：
    1. 终止条件：都是空的 说明到了根节点，两边结构相同；
    2. 终止条件：一边空一边不空，说明两边结构不同；
    3. 值不等；
class TreeNode:
    def __init__(self, val=0, right=None, left=None):
        self.val = val
        self.right = right
        self.left = left

class Solution:
    def isSameTree(self, p, q):
        if not p and not q:
            return True
        if (not p and q) or (p and not q): # if not p or not q:
            return False
        if p.val != q.val:
            return False
        return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

572. Subtree of Another Tree

  • 我的直观：从根节点开始判断是否是同一棵树(复用[100])，不是判断左右子树[相当于每个节点都判断了一遍是否是Same Tree]
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, subRoot):
        def isSameTree(p, q):
            if not p and not q:
                return True
            if not p or not q:
                return False
            if p.val != q.val:
                return False
            return isSameTree(p.left, q.left) and isSameTree(p.right, q.right)
        if not root:
            return False
        if isSameTree(root, subRoot):
            return True
        return self.isSubtree(root.left, subRoot) or self.isSubtree(root.right, subRoot)

235. Lowest Common Ancestor of a Binary Search Tree

已患月岛萤综合症
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode-tree
04-19
144-Binary Tree Preorder Traversal94-Binary Tree Inorder Traversal145-Binary Tree Postorder Traversal（后续的非递归时间不够可以先跳过，有点难）层次遍历，队列辅助，相当于广搜。102-Binary Tree Level ...
leetcode-tag-Tree
04-29
leetcode-tag-Tree
LeetCode | Same Tree
03-01 476
题目 Given two binary trees, write a function to check if they are equal or not. Two binary trees are considered equal if they are structurally identical and the nodes have the same value. 分析
LeetCode | Balanced Binary Tree
Allan的专栏
09-21 4903
题目： Given a binary tree, determine if it is height-balanced. For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees ofevery node nev
LeetCode｜700. Search in Binary Search Tree
iLOVEJohnny的博客
05-09 397
简单不考虑BST的特性，直接遍历全部二叉树的所有节点。当找到目标节点后，即直接返回。
leetcode | sql | 第608题 | 树节点
iCling的博客
12-27 360
【代码】leetcode | sql | 第608题 | 树节点。
leetcode | go | 第732题 | 我的日程安排表Ⅲ
iCling的博客
01-18 358
【代码】leetcode | go | 第732题 | 我的日程安排表Ⅲ。
leetcode | go | 第965题 | 单值二叉树
iCling的博客
03-05 329
【代码】leetcode | go | 第965题 | 单值二叉树。
leetcode | go | 第998题 | 最大二叉树Ⅱ
iCling的博客
03-09 348
【代码】leetcode | go | 第998题 | 最大二叉树Ⅱ。
LeetCode | 563. Binary Tree Tilt
pku_Coder的博客
04-25 1270
Given a binary tree, return the tilt of the whole tree.The tilt of a tree node is defined as the absolute difference between the sum of all left subtree node values and the sum of all right subtree nod
leetcode | python | 第144题 | 二叉树的前序遍历
iCling的博客
03-29 395
【代码】leetcode | python | 第144题 | 二叉树的前序遍历。
LeetCode | 144. Binary Tree Preorder Traversal
iLOVEJohnny的博客
09-30 1718
题目： Given therootof a binary tree, returnthe preorder traversal of its nodes' values. Example 1: Input: root = [1,null,2,3] Output: [1,2,3] Example 2: Input: root = [] Output: [] Example 3: Input: root = [1] Output: [1] Example 4: ...
讨厌刷leetcode-tree-parser:树解析器
06-30
讨厌刷leetcode 为了解析后端数据，我竟然写了个递归？ 代码仓库： 曾经的我特别讨厌 LeetCode 算法题，当时就觉得写项目好玩，算法没什么用。不喜欢归不喜欢，为了面试，还是写了 476 道题 = =。非常感激默默地刷题...
leetcode添加元素使和等于-Leetcode-tree:力码树
06-30
Leetcode-tree 94题 Binary Tree Inorder Traversal 对于树的问题，大多数我们都会使用递归的方法。原因是树的左子树也是树，右子树也是树，使用递归的方法最简单快捷。这道题是需要我们用Inorder的顺序输出节点。in...
LeetCode Permutation
04-19
Source file for LeetCode Permutations Problem
基于自编码器的心电图信号异常检测（Python）
weixin_39402231的博客
06-17 552
使用的数据集来自PTB心电图数据库，包括14552个心电图记录，包括两类：正常心跳和异常心跳，采样频率为125Hz。
大模型基础——从零实现一个Transformer(5)
fan_fan_feng的专栏
06-18 377
上一篇文章已经把Encoder模块和Decoder模块都已经实现了，接下来来实现完整的Transformer。
23.2 时间-定时器、格式化时间
AlieNeny的博客
06-18 872
介绍了go语言背景下的时间定时器、格式化方式与代码实践。
通过xml配置实现数据动态导入导出Excel
最新发布
u010465417的博客
06-19 777
spring-dj-excel-common.jar 一个可以通过动态配置 xml 建立 Excel 与数据关系现实数据导入导出的 spring 组件包，在 xml 配置文件里，你可以很方便的定义 Excel - sheet 表列头文本与数据表、数据实体属性的对应关系，对于创建 Excel 文件，你可以通过增加某一标签列的子项实现列头跨列展示效果，同时你也可以通过设置列头对应的样式属性 headStyle 来设置sheet表列头的文字、颜色、边框的展示效果，你也可以针对每一列进行单独的样式设置。
leetcode常用算法
02-27
9. 二叉树的最大深度（Maximum Depth of Binary Tree）：计算二叉树的最大深度，即从根节点到最远叶子节点的最长路径上的节点数。 10. 两个排序数组的中位数（Median of Two Sorted Arrays）：给定两个大小为m和n的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值