代码随想录算法训练营DAY15｜层序遍历 10、226.翻转二叉树、101.对称二叉树 2

已于 2024-05-23 16:24:08 修改
阅读量366 收藏 4
点赞数 1
分类专栏： 代码随想录打卡 文章标签： 算法
于 2024-05-23 15:39:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Greeneril_/article/details/139149702
版权

层序遍历

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
            
        queue = collections.deque([root])
        result = []

        while queue:
            level = []
            for _ in range(len(queue)):
                node = queue.popleft()
                level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(level)
        return result        

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        
        queue = collections.deque([root])
        result = []

        while queue:
            level = []
            for _ in range(len(queue)):
                node = queue.popleft()
                level.append(node.val)

                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.insert(0, level)
        
        return result

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        
        queue = collections.deque([root])
        result = []
        
        while queue:
            result.append(queue[-1].val)
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        
        return result

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def averageOfLevels(self, root):
        """
        :type root: TreeNode
        :rtype: List[float]
        """

        if not root:
            return []
        
        queue = collections.deque([root])
        result = []
        
        while queue:
            level = []
            for _ in range(len(queue)):
                node = queue.popleft()
                level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(sum(level)/float(len(level)))
        
        return result

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def largestValues(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        
        queue = collections.deque([root])
        result = []
        
        while queue:
            level = []
            for _ in range(len(queue)):
                node = queue.popleft()
                level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(max(level))
        
        return result

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        
        queue = collections.deque([root])
        result = 0
        
        while queue:
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result += 1
        
        return result

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        
        queue = collections.deque([root])
        result = 0
        
        while queue:
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
				# 叶子结点
                if not node.left and not node.right:
                    return result+1
            result += 1
        
        return result

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

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        if not root:
            return []
        
        queue = collections.deque([root])
        result = []
        
        while queue:
            level = []
            for _ in range(len(queue)):
                node = queue.popleft()
                level.append(node.val)
                for child in node.children:
                    queue.append(child)
            result.append(level)
            
        return result

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=0, left=None, right=None, next=None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution(object):
    def connect(self, root):
        """
        :type root: Node
        :rtype: Node
        """
        if not root:
            return root

        queue = collections.deque([root])

        while queue:
            l = len(queue)
            for i in range(l):
                node = queue.popleft()
                if i<l-1:
                    node.next = queue[0]
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        
        return root

226.翻转二叉树

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return
        self.invertTree(root.left)
        self.invertTree(root.right)
        root.left, root.right = root.right, root.left

        return root
  • 层序遍历迭代法
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def invertTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return root
    
        queue = collections.deque([root])

        while queue:
            for _ in range(len(queue)):
                node = queue.popleft()
                node.left, node.right = node.right, node.left

                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return root

101.对称二叉树

  • 题目链接：101.对称二叉树
  • 迭代法
    • 思路类似于层次遍历，但节点加入的顺序不同
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return False

        queue = collections.deque([root.left, root.right])

        while queue:
            node1 = queue.popleft()
            node2 = queue.popleft()
            
            if not node1 and not node2:
                continue
            elif not node1 or not node2:
                return False

            if node1.val!=node2.val:
                return False

            queue.append(node1.left)
            queue.append(node2.right)
            queue.append(node1.right)
            queue.append(node2.left)
        
        return True
  • 递归法
    • compare(left.left, right.right)
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def compare(self, left, right):
        if not right and not left:
            return True
        elif not right or not left:
            return False
        elif right.val != left.val:
            return False
        
        left_res = self.compare(left.left, right.right)
        right_res = self.compare(left.right, right.left)

        if left_res and right_res:
            return True
        else:
            return False

    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        
        return self.compare(root.left, root.right)
阿緑
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
二叉树的遍历以及创建.zip
04-30
二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的...
代码随想录算法训练营Day15 | 层序遍历 10 226.翻转二叉树 101.对称二叉树 2
qq_24817679的博客
04-18 429
思路：1.用queue收集left和right节点，并push front节点。思路：反向输出正序即可思路：1.push最后一个值思路：求mean；注意： 平均值变量为double思路：多节点思路：获取最大值思路：1.用Node pre记录前一个节点，将其指向下一个节点；2.最后一个节点需要指向NULL思路：同116思路：层次遍历每个循环记录depth思路：如果没有左右节点就return。
代码随想录算法训练营DAY 15| 层序遍历 10 226.翻转二叉树 101.对称二叉树 2
ll0205的博客
04-20 154
要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。判断对称二叉树，比较的是两个树（这两个树是根节点的左右子树），比较的是两个子树的里侧和外侧的元素是否相等。思路：把每一个节点的左右孩子交换一下，使用前序遍历和后序遍历。别忘记空节点，数值不相同的情况。
代码随想录算法训练营Day 13|Python|层序遍历，226.翻转二叉树，101.对称二叉树
qq_60959261的博客
04-03 580
设置一个新的deque用来存储遍历的节点，弹出每个最左边的节点，检查是否有左右children， 有的话加入deque，每一层设置一个新的list用来存储这一层的节点value，list针对每一层都会更新。递归逻辑：left.val == right.val继续对比left.left, right.right；确定输入和参数：def compare(left, right)比较左右两边，因此输入left child nad right child。，翻转这棵二叉树，并返回其根节点。给你一个二叉树的根节点。
代码随想录算法训练营Day13 | 层序遍历 10、226.翻转二叉树 、101.对称二叉树2
宁愿过拟合不要欠拟合
05-07 859
二叉树：层序遍历、反转二叉树、对称二叉树
代码随想录算法训练营day15 | 层序遍历 10，226.翻转二叉树，101.对称二叉树 2
2301_77450803的博客
04-19 289
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
代码随想录算法训练营第十五天 | 层序遍历 ， 226.翻转二叉树 ， 101.对称二叉树 2
m0_52419043的博客
04-18 210
其实就是遍历二叉树的应用，这里面要注意的思路，只要将所有节点的左右孩子都交换就行，所以目标是遍历所有的节点并对每一节点进行操作（也就是交换左右孩子），所以才可以对原始的二叉树进行遍历。Node*是定义树的，用node->children[ i ]来说明孩子，node->children.size()表示孩子的长度。迭代法，跟遍历的区别就是 每次操作要两个对应的节点，插入的时候也是对应的插入。（最小值），然后更新就可以了。递归法：其实就是遍历左子树，然后对应的遍历右子树。
代码随想录训练营Day15|层序遍历|226.翻转二叉树|101.对称二叉树 2
yy19991222的博客
06-21 218
借助队列结构，保存每一层保存过的元素，size记录当前层大小，决定当前层弹出多少元素；弹出一个元素，就在后续加入他的左右子元素；一层结束，size==0后，队列中全为下一层元素，此时更新size，开始进行该层的弹出，以及下一层的压入。117.填充每个节点的下一个右侧节点指针II。116.填充每个节点的下一个右侧节点指针。107.二叉树的层次遍历II。如何一层一层的保存节点？102.二叉树的层序遍历。637.二叉树的层平均值。104.二叉树的最大深度。111.二叉树的最小深度。199.二叉树的右视图。
代码随想录算法训练营刷题Day15|层序遍历10、226.翻转二叉树、101.对称二叉树 2
weixin_43446964的博客
04-23 121
199：给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。2、具体过程：将节点加入队列；记录当前层的节点个数；弹出有节点个数的节点，并将左右子节点加入队列。2、第一次写没写出来，思路出错，就想用层序遍历再额外加一个数据结构去写，但是有很多问题。4、注意记录每次弹出的次数，而且不能用que.size()，因为que的长度是变化的。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）：给你一个二叉树的根节点。：给你二叉树的根节点。：给你二叉树的根节点。
代码随想录算法训练营Day15 | ● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2
2401_82757749的博客
06-05 440
首先当左右结点都为空时，代表这两个树相等，而当其中一个为空，或者是数值都不相等的时候，肯定是不相等的，这样我们的减枝工作就完成了，下面的情况就是数值相等的情况，下面就是要看他们的结点是不是对称的了，对称看的是左节点的节点是不是和右节点的右节点相等，和左节点的右节点是不是和右节点的左节点相等，然后定于两个bool类型的变量outside和inside用来记录这两个子树是否相等，然后返回即可。二叉树的层序遍历主要是通过队列这种数据结构来实现的，下面来看第一题，这题还是很简单的，直接上代码。
基于Java的二叉树层序遍历打印实现.docx
06-27
二叉树的遍历是对其进行操作和分析的基础方法，其中包括前序遍历、中序遍历和后序遍历。层序遍历，又称按层次遍历，是从树的第一层开始，自上而下逐层访问每个节点，并在同一层内从左到右遍历。这种遍历方式常用于...
python-leetcode面试题解之第102题二叉树的层序遍历-题解.zip
04-29
此外，掌握层序遍历不仅对解决LeetCode题目有帮助，也是面试其他数据结构和算法问题的基础，如二叉树的镜像、判断两棵树是否相同等。 总结来说，Python LeetCode面试题解中的第102题——二叉树的层序遍历，是学习和...
8606-二叉树的构建及遍历操作.rar_二叉树_遍历算法
09-21
用户可以通过阅读代码了解二叉树的构建方法和遍历算法的具体实现细节，也可以直接运行代码进行测试，加深对二叉树的理解。同时，这是一个很好的实践项目，可以帮助初学者巩固数据结构基础，提高编程技能。 总结来说...
【18】输出字符菱形
2301_78786609的博客
07-19 287
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 108
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 186
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
常见的排序算法，复杂度
m0_61544805的博客
07-16 516
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值