蓝桥杯 第7天 树（1）

已于 2022-01-25 21:28:49 修改
阅读量821 收藏
点赞数
文章标签： 蓝桥杯 职场和发展
于 2022-01-25 21:28:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aixiaoxiao13/article/details/122690828
版权

目录

1.建树

2.中序遍历

（1）递归

（2）迭代

3.先序遍历

（1）递归

（2）迭代

4.后序遍历

（1）递归

（2）迭代

5.102. 二叉树的层序遍历 - 力扣（LeetCode） (leetcode-cn.com)

6.107. 二叉树的层序遍历 II - 力扣（LeetCode） (leetcode-cn.com)

7.199. 二叉树的右视图 - 力扣（LeetCode） (leetcode-cn.com)

8.637. 二叉树的层平均值 - 力扣（LeetCode） (leetcode-cn.com)

9.429. N 叉树的层序遍历 - 力扣（LeetCode） (leetcode-cn.com)

10.515. 在每个树行中找最大值 - 力扣（LeetCode） (leetcode-cn.com)

11.116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode） (leetcode-cn.com)

12.117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode） (leetcode-cn.com)

13.104. 二叉树的最大深度 - 力扣（LeetCode） (leetcode-cn.com)

14.111. 二叉树的最小深度 - 力扣（LeetCode） (leetcode-cn.com)

1.建树

很不熟悉类

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

2.中序遍历

（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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        martix=[]
        def traversal(root):
            if root==None:return
            traversal(root.left)
            martix.append(root.val)
            traversal(root.right)
        traversal(root)
        return martix

（2）迭代

# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result=[]
        if root==None:
            return result
        #左中右
        stack=[]
        cur=root
        while cur or stack:
            if cur:
                stack.append(cur)
                cur=cur.left
            else:
                cur = stack.pop()
                result.append(cur.val)
                cur=cur.right
        return result

3.先序遍历

（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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        martix=[]
        def traversal(root):
            if root==None:return
            martix.append(root.val)
            traversal(root.left)
            traversal(root.right)
        traversal(root)
        return martix

（2）迭代

# 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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result=[]
        if root==None:return result
        stack=[root]
        while stack:
            top=stack.pop()
            result.append(top.val)
            if top.right:
                stack.append(top.right)
            if top.left:
                stack.append(top.left)
        return result

4.后序遍历

（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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        martix=[]
        def traversal(root):
            if root==None:return
            traversal(root.left)
            traversal(root.right)
            martix.append(root.val)
        traversal(root)
        return martix

（2）迭代

# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        result=[]
        if root==None:
            return result
        stack=[root]
        while stack:
            top=stack.pop()
            result.append(top.val)
            if top.left:
                stack.append(top.left)
            if top.right:
                stack.append(top.right)
        return result[::-1]

5.102. 二叉树的层序遍历 - 力扣（LeetCode） (leetcode-cn.com)

# 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 levelOrder(self, root: TreeNode) -> List[List[int]]:
        results=[]
        if root==None:
            return results
        from collections import deque
        que=deque([root])
        while que:
            size=len(que)
            result=[]
            for i in range(size):
                top=que.popleft()
                result.append(top.val)
                if top.left:
                    que.append(top.left)
                if top.right:
                    que.append(top.right)
            results.append(result)
        return results

6.107. 二叉树的层序遍历 II - 力扣（LeetCode） (leetcode-cn.com)

# 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 levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        results=[]
        if root==None:
            return results
        from collections import deque
        que=deque([root])
        while que:
            size=len(que)
            result=[]
            for i in range(size):
                top=que.popleft()
                result.append(top.val)
                if top.left:
                    que.append(top.left)
                if top.right:
                    que.append(top.right)
            results.append(result)
        return results[::-1]

7.199. 二叉树的右视图 - 力扣（LeetCode） (leetcode-cn.com)

# 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 rightSideView(self, root: TreeNode) -> List[int]:
        result=[]
        if root==None:
            return result
        from collections import deque
        que=deque([root])
        while que:
            size=len(que)
            for i in range(size):
                top=que.popleft()
                if i==size-1:
                    result.append(top.val)
                if top.left:
                    que.append(top.left)
                if top.right:
                    que.append(top.right)
        return result

8.637. 二叉树的层平均值 - 力扣（LeetCode） (leetcode-cn.com)

# 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: Optional[TreeNode]) -> List[float]:
        results=[]
        if root==None:
            return results
        from collections import deque
        que=deque([root])
        while que:
            size=len(que)
            result=[]
            for i in range(size):
                top=que.popleft()
                result.append(top.val)
                if top.left:
                    que.append(top.left)
                if top.right:
                    que.append(top.right)
            results.append(sum(result)/size)
        return results

9.429. N 叉树的层序遍历 - 力扣（LeetCode） (leetcode-cn.com)

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        results=[]
        if root==None:
            return results
        from collections import deque
        que=deque([root])
        while que:
            size=len(que)
            result=[]
            for i in range(size):
                top=que.popleft()
                result.append(top.val)
                for j in range(len(top.children)):
                    que.append(top.children[j])
            results.append(result)
        return results

10.515. 在每个树行中找最大值 - 力扣（LeetCode） (leetcode-cn.com)

# 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 largestValues(self, root: Optional[TreeNode]) -> List[int]:
        results=[]
        if root==None:
            return results
        from collections import deque
        que=deque([root])
        while que:
            size=len(que)
            result=[]
            for i in range(size):
                top=que.popleft()
                result.append(top.val)
                if top.left:
                    que.append(top.left)
                if top.right:
                    que.append(top.right)
            results.append(max(result))
        return results

11.116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode） (leetcode-cn.com)

"""
# Definition for a Node.
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: 'Optional[Node]') -> 'Optional[Node]':
        results=[]
        if not root:
            return root
        from collections import deque
        que=deque([root])
        while que:
            size=len(que)
            result=[]
            for i in range(size):
                top=que.popleft()
                result.append(top.val)
                if top.left:
                    que.append(top.left)
                if top.right:
                    que.append(top.right)
                if i!=size-1:
                    top.next=que[0]
        return root

12.117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode） (leetcode-cn.com)

代码都一模一样

"""
# Definition for a Node.
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: 'Node') -> 'Node':
        results=[]
        if not root:
            return root
        from collections import deque
        que=deque([root])
        while que:
            size=len(que)
            result=[]
            for i in range(size):
                top=que.popleft()
                result.append(top.val)
                if top.left:
                    que.append(top.left)
                if top.right:
                    que.append(top.right)
                if i!=size-1:
                    top.next=que[0]
        return root

13.104. 二叉树的最大深度 - 力扣（LeetCode） (leetcode-cn.com)

# 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:
        results=[]
        if not root:
            return 0
        from collections import deque
        que=deque([root])
        depth=0
        while que:
            depth+=1
            size=len(que)
            result=[]
            for i in range(size):
                top=que.popleft()
                result.append(top.val)
                if top.left:
                    que.append(top.left)
                if top.right:
                    que.append(top.right)
        return depth

14.111. 二叉树的最小深度 - 力扣（LeetCode） (leetcode-cn.com)

# 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
        from collections import deque
        que=deque([root])
        depth=0
        while que:
            depth+=1
            size=len(que)
            result=[]
            for i in range(size):
                top=que.popleft()
                if top.left==top.right==None:
                    return depth
                if top.left:
                    que.append(top.left)
                if top.right:
                    que.append(top.right)
        return depth

是小肖啊！
关注
蓝桥杯第七届决赛题
03-22
【蓝桥杯第七届决赛题】涉及的是2018年蓝桥杯嵌入式比赛的决赛题目，这类竞赛通常涵盖了一系列的编程与嵌入式系统相关的技术知识点。蓝桥杯是一项国内知名的IT技能竞赛，旨在考察参赛者的编程能力、算法理解以及在...
蓝桥杯第7、8届竞赛试题（C、java组）
01-12
总的来说，蓝桥杯第7、8届竞赛试题涵盖了C和Java的核心知识点，是学习和提升编程技能的理想资源。无论是对C语言的底层理解和高效算法，还是Java的面向对象设计和数据结构应用，以及Eclipse的实用技巧，都能在解答...
蓝桥杯-树上选点
weixin_60193316的博客
03-24 336
【代码】蓝桥杯-树上选点。
第十二届蓝桥杯国赛括号线段树
goto_1600的博客
06-12 565
题面： 题意： 操作1 把区间括号翻转 操作2 查询最长合法括号序列序列从l开始 思路： 类似于区间合并的问题，对于每个区间我们记录左右最小最大前缀值，我们把(看作1,)看作-1，合法的括号序列满足于当前的sum=0且对于任意前缀都是>=0，那么满足二分性质，我们可以二分套线段树查询到从l开始满足前缀大于等于0的最大位置，然后如果下个位置的sum<0那么就是当前位置，但是会有可能是查询到n，然后后面没数了且sum>0，那么我们就要二分出第一个后缀最大值等于sum的位置。 调了一下午调的心
蓝桥杯第十三讲--树状数组与线段树【习题】
佛系更新
02-15 1066
蓝桥杯官网：蓝桥杯大赛——全国大学生TMT行业赛事；本博客讲解 蓝桥杯C/C++ 备赛所涉及算法知识，此博客为第十三讲：树状数组与线段树【习题】本篇博客所包含习题有：小朋友排队，油漆面积；树状数组与线段树【例题】见博客：蓝桥杯第十三讲–树状数组与线段树【例题】博客内容以题代讲，通过讲解题目的做法来帮助读者快速理解算法内容，需要注意：学习算法不能光过脑，更要实践，请读者务必自己敲写一遍本博客相关代码！！！
蓝桥杯java生成树计数_第七届蓝桥杯决赛杂记
weixin_28318011的博客
03-02 256
反正最近不想干什么正经事，回忆一下这些东西也好。总的来说，这是我第二次去北京参加蓝桥杯决赛。去年获得了优秀奖，换句话来说就是重在参与。不过，今年成绩比去年好一点。(订的宾馆一如既往的温馨就不说了)首先，今年我的比赛地点是在北京建筑大学(西城校区)。顾名思义就知道这所学校的建筑系比较有名，不过这和我没有什么关系。这学校位于北京市内，又由于建的比较早，所以进去之后发现植被非常的茂盛，另一方面就是校园建...
蓝桥杯第一天
weixin_73869857的博客
03-11 59
小明决定从下周一开始努力刷题准备蓝桥杯竞赛。他计划周一至周五每天做 a 道题目，周六和周日每天做 b 道题目。请你帮小明计算，按照计划他将在第几天实现做题数大于等于 n 题？
蓝桥杯第16天（Python版）（图论）
weixin_52261094的博客
03-28 376
问题是求中位数的中位数，上面解题思路图便于理解。
蓝桥杯第十三讲--树状数组与线段树【例题】
佛系更新
02-12 1565
蓝桥杯官网：蓝桥杯大赛——全国大学生TMT行业赛事；本博客讲解 蓝桥杯C/C++ 备赛所涉及算法知识，此博客为第十三讲：树状数组与线段树【例题】本篇博客所包含习题有：动态求连续区间和，数星星，数列区间最大值；树状数组与线段树【习题】见博客：蓝桥杯第十三讲–树状数组与线段树【习题】博客内容以题代讲，通过讲解题目的做法来帮助读者快速理解算法内容，需要注意：学习算法不能光过脑，更要实践，请读者务必自己敲写一遍本博客相关代码！！！
蓝桥杯：线段树、树状数组
m0_56039061的博客
02-12 576
介绍数状数组和线段树的基础用法。
蓝桥杯 第几个幸运树
拥抱技术
04-02 221
害，一开始是想写一个check函数分解质因数判断一个数是否满足条件，再从1到目标数枚举求出最后的次数如下，结果可想而知。时间复杂度太大，而且好像也运行不了。 #include<bits/stdc++.h> using namespace std; int cnt; typedef long long LL; const LL ans=59084709587505; bool check(LL a) { for(int i=2;i<=a/i;i++) {
蓝桥杯python第5天，python-Day05.rar
04-30
在“蓝桥杯Python第5天”的学习中，我们聚焦于Python编程语言的关键概念和技巧，这是准备蓝桥杯竞赛的重要部分。这个压缩包“python-Day05.rar”可能包含了讲义、练习题、代码示例等资源，帮助学生深化对Python的...
蓝桥杯第十三届国赛程序设计题
05-22
第十三届蓝桥杯国赛程序设计题无疑是对参赛者编程技巧的一次严峻考验，涵盖了一系列的算法和数据结构问题。 在准备蓝桥杯竞赛时，参赛者需要对以下几个关键知识点有深入的理解和熟练的运用： 1. **基础算法**：...
2018_第九届_蓝桥杯_省赛_电子定时器.rar
09-06
《2018_第九届_蓝桥杯_省赛_电子定时器》是一个与编程竞赛相关的资源包，其中包含了参与2018年蓝桥杯省赛的电子定时器项目代码。蓝桥杯是一项全国性的专业软件和信息技术人才的竞赛，旨在提升参赛者的编程技能和创新...
some 蓝桥杯题
最新发布
2301_80160438的博客
10-02 379
【代码】some 蓝桥杯题。
准备蓝桥杯和ACM：C++标准库头文件及其常用功能简介
WenJGo的博客
09-28 1134
采用C++比赛常用语法总结
蓝桥杯—STM32G431RBT6(RTC时钟获取时间和日期)
JK03820的博客
09-29 1717
在LCD函数中获取值 注意，两个都要获取一下，不然容易出毛病 在LCD中显示 四、开源代码 通过网盘分享的文件：19-TEST9-RTC实时时钟.zip 链接: https://pan.baidu.com/s/150G8rln1ZEBG1QCZBqrMAQ?pwd=0820 提取码: 0820
蓝桥杯15届C/C++B组省赛题目
m0_73096516的博客
09-19 2520
队伍 1： {a1,a2,a3}{a1​,a2​,a3​}，队伍 2：{a4,a5}{a4​,a5​}，力量值和分别为 10+9+8=2710+9+8=27 , 12+14=2612+14=26，差距为 ∣27−26∣=1∣27−26∣=1。对于路径经过的棋盘格子，按照经过的格子顺序，上面的数字组成的序列要满足：0,1,2,…,K−1,0,1,2,…例如之前有从 (0,0)(0,0) 移动到 (1,1)(1,1) ，那么再从 (1,0)(1,0) 移动到 (0,1)(0,1) 线路就会交叉。
蓝桥杯第七届单片机决赛：设计电压频率采集设备
第七届蓝桥杯全国软件和信息技术专业人才大赛个人赛电子类决赛的单片机设计与开发项目是一份实践性强的试题，主要考察参赛者的硬件设计、编程能力以及对电子技术的理解。题目围绕“电压、频率采集设备”展开，具体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值