算法题day14：

最新推荐文章于 2024-08-14 12:02:23 发布
最新推荐文章于 2024-08-14 12:02:23 发布
阅读量685 收藏 7
点赞数 6
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TIANBIU/article/details/138451365
版权
文章详细介绍了二叉树的层次遍历方法，包括队列的应用，并列举了LeetCode中的多个与二叉树层序遍历、右视图、层平均值、N叉树遍历、最大值查找、填充节点指针、树深度计算以及完全二叉树节点数等问题及其解决方案，涉及多种算法实现方式。
摘要由CSDN通过智能技术生成

一、二叉树的层次遍历：

1.遍历步骤：从左到右一层一层的去遍历二叉树

2.使用队列

二、刷题：

1.leetcode题目102 二叉树的层序遍历（medium)：

题目描述：102. 二叉树的层序遍历 - 力扣（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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        res = []
        queue = collections.deque([root])
        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            res.append(level)
        return res

2.leetcode题目107 二叉树的层序遍历（medium）：

题目描述：107. 二叉树的层序遍历 II - 力扣（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 levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        res = []
        queue = collections.deque([root])
        if root is None:
            return []
        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            res.append(level)
        return res[::-1]

3.leetcode题目199 二叉树的右视图（medium）：

题目描述：199. 二叉树的右视图 - 力扣（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 rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        queue = collections.deque([root])
        if root is None:
            return []
        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.right:
                    queue.append(cur.right)
                if cur.left:
                    queue.append(cur.left)
            res.append(level[0])
        return res

4.leetcode题目 二叉树的层平均值（easy）：

题目描述：637. 二叉树的层平均值 - 力扣（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 averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        res = []
        queue = collections.deque([root])
        if root is None:
            return []
        while queue:
            level_sum = 0
            l = len(queue)
            for _ in range(len(queue)):
                cur = queue.popleft()
                level_sum += cur.val
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            res.append(level_sum/l)
        return res

5. leetcode题目429 N叉树的层序遍历（medium）：

题目描述：429. N 叉树的层序遍历 - 力扣（LeetCode）

解决：

"""
# 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]]:
        res = []
        queue = collections.deque([root])
        if root is None:
            return []
        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.children:
                    for child in cur.children:
                        queue.append(child)
            res.append(level)
        return res

6.leetcode 题目 515 在每个树行中找最大值（medium）：

题目描述：515. 在每个树行中找最大值 - 力扣（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 largestValues(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        queue = collections.deque([root])
        if root is None:
            return []
        while queue:
            max_l = -10**10
            for _ in range(len(queue)):
                cur = queue.popleft()
                max_l = max(max_l,cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            res.append(max_l)
        return res

7.leetcode题目 116 填充每一个节点的下一个右侧节点指针(medium）：

题目描述：116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

解决：

"""
# 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]':
        queue = collections.deque([root])
        if not root:
            return root
        while queue:
            l = len(queue)
            for i in range(l):
                cur = queue.popleft()
                if i < l-1:
                    cur.next = queue[0]
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return root

8.leetcode题目 117 填充每一个节点的下一个右侧节点指针II(medium）：

题目描述：117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）

解决：

"""
# 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':
        queue = collections.deque([root])
        if not root:
            return root
        while queue:
            l = len(queue)
            
            for i in range(l):
                cur = queue.popleft()
                if i < l-1:
                    cur.next = queue[0]
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
    
        return root

9.leetcode题目 104 二叉树的最大深度（easy）：

题目描述：104. 二叉树的最大深度 - 力扣（LeetCode）

解决：

①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:
        depth = 0
        queue = collections.deque([root])
        if not root:
            return depth
        while queue:
            depth += 1
            for _ in range(len(queue)):
                cur = queue.popleft()
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return depth

②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 maxDepth(self, root: Optional[TreeNode]) -> int:

        if not root:
            return 0
        else:
            left_height = self.maxDepth(root.left)
            right_height = self.maxDepth(root.right)
            return max(left_height,right_height) + 1

10. leetcode题目111 二叉树的最小深度（easy）：

注意：只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点。

题目描述：111. 二叉树的最小深度 - 力扣（LeetCode）

解决：

①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: Optional[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

②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 minDepth(self, root: Optional[TreeNode]) -> int:
        queue = collections.deque([root])
        min_depth = 0
        if not root:
            return 0
        if not root.left and not root.right:
            return 1
        while queue:
            min_depth += 1
            for _ in range(len(queue)):
                cur = queue.popleft()
                if not cur.left and not cur.right:
                    return min_depth
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return min_depth

11.leetcode题目 222 完全二叉树的节点个数（easy）：

题目描述：222. 完全二叉树的节点个数 - 力扣（LeetCode）

解决：

①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 countNodes(self, root: Optional[TreeNode]) -> int:
        num = 0
        queue = collections.deque([root])
        if not root:
            return 0
        while queue:
            for _ in range(len(queue)):
                cur = queue.popleft()
                num += 1
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return num

②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 countNodes(self, root: Optional[TreeNode]) -> int:
        num_left = 0
        if not root:
            return 0
        else:
            num_left = self.countNodes(root.left)
            num_right = self.countNodes(root.right)
        return num_left+num_right+1

12.leetcode题目 226 翻转二叉树（easy）：

题目描述：

解决：

①迭代法

# 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: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None
        stack = [root]
        while stack:
            node = stack.pop()
            node.left,node.right = node.right,node.left
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return root

②递归法：

# 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: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None
        node = root
        node.left,node.right = node.right,node.left
        node.left = self.invertTree(node.left)
        node.right = self.invertTree(node.right)
        return node

TIANBIU
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
数据结构算法题day03
自学记录
05-28 357
【代码】数据结构算法题day03。
java算法题Day9
weixin_52618349的博客
05-01 1017
Leecode94 Leecode100
算法训练Day3：移除链表元素，设计链表，反转链表
qq_45865950的博客
03-18 3459
移除链表元素，设计链表，反转链表
java算法题 Day10
weixin_52618349的博客
05-01 511
Leecode101 Leecode104
java算法题 Day8
weixin_52618349的博客
04-29 586
Leecode83 Leecode88
java算法题 Day1
weixin_52618349的博客
04-21 583
Leecode1 Leecode7
java算法题 Day2
weixin_52618349的博客
04-23 382
Leecode14 Leecode20
算法刷题day49：线性DP—最长上升子序列模型
weixin_60033897的博客
05-19 1069
写完了线性 $DP$ 的十道题之后，我感觉得到了一种升华，今天花了大概七八个小时吧，感觉就是理解的越来越深了，以前都是背过来了，现在能明白有些东西为什么要这样，或者说还可以那样写。尤其是导弹防御的问题，让自己对暴搜和迭代加深的印象也越来越深了， $DP$ 和暴搜其实是一家的，而且要准备蓝桥杯国赛，主要就是准备 $DP$ 和暴搜，图论其后，剩余的就把基础课的东西整明白就行了，然后再针对性的多刷刷题，坚持下去，一定不会差，加油！
算法题day39（补5.25日卡：贪心算法day6）
TIANBIU的博客
06-03 367
1.leetcode题目。
考研数据结构算法题总结
热心上单小张的博客
10-18 5090
考研数据结构100天 Day1：在带头结点的单链表L中，删除所有值为X的节点，并释放其空间，假设值为的X节点不唯一，试编写算法以实现上述操作 void Del-X(LinkList &L,int x){ LNode *p=L->next; LNode *pre=L; LNode *q; while(p!=NULL){ if(p->data==x){ q=p; p=p->next; pre->next=p; free(q); }else{
leetcode算法题主函数如何写-one_algorithm_one_day:每天一道算法题
06-30
leetcode算法题主函数如何写 one_algorithm_one_day 每天一道算法题 为了应付面试，开始写博客，准备开三个系列，第一个 JS算法系列，主要整理一些面试过程中常见的算法题 ； 第二个 ECMAScript规范解析，主要是想从...
NOIP2016复赛试题day1.pdf
02-06
本题要求实现一个简单的字符串处理算法，通过输入的字符串来判断某些特定条件下的结果。 **输入**： - 输入文件名为`toy.in`。 - 第一行包含一个整数`n`，表示接下来会有`n`行数据。 - 接下来的`n`行，每行包含两个...
NOIP2014复赛试题day2.pdf
02-06
### NOIP2014复赛试题day2知识点解析 #### 一、竞赛基本信息 - **竞赛名称**：全国信息学奥林匹克联赛（NOIP2014）复赛提高组day2 - **时间限制**：每个测试点时限1秒 - **空间限制**：128M - **测试点数目**：...
春节7天练丨Day6：图1
08-03
这里主要涉及的是图的算法实践，通过LeetCode上的练习题来加深理解。 【部分内容】提到了以下几个关于图的知识点： 1. **图的表示方法**： - **邻接矩阵**：使用二维数组表示图中顶点之间的连接关系，对于无权图...
春节7天练丨Day5：二叉树和堆1
08-03
LeetCode网站提供了几个与二叉树和堆相关的练习题，如翻转二叉树、计算二叉树的最大深度、验证二叉查找树和寻找路径总和等。这些问题可以帮助我们深入理解并熟练掌握二叉树和堆的操作。 在实际编程中，二叉树和堆的...
算法的学习笔记—删除链表中重复的结点（牛客JZ76）
业精于勤，荒于嬉
08-14 1254
本文介绍了一种删除排序链表中重复节点的高效算法。通过递归的方式，算法能够有效地删除所有重复节点，并保留链表中仅出现一次的节点。此方法的实现简单且易于理解，同时在时间和空间复杂度方面表现优异，适用于处理大规模数据链表中的重复节点问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 864
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
【LeetCode每日一题】——623.在二叉树中增加一行
IronmanJay的博客
08-14 1179
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
LeeCode Practice Journal | Day43_DP10
最新发布
Janniam的博客
08-14 294
上题的变体，与nums[i]前每一个连续的元素比较变为前一个元素比较。2、返回值不是dp[i]，是dp数组中的最大值。1、数组元素要初始化为1。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值