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

已于 2024-05-23 16:24:08 修改
阅读量461 收藏 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)
阿緑
关注
专栏目录
算法训练day15Leetcode102二叉树层序遍历226翻转二叉树101对称二叉树
dc爱傲雪和技术
01-15 1021
对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
代码随想录算法训练营Day15 | 层序遍历 10 226.翻转二叉树 101.对称二叉树 2
qq_24817679的博客
04-18 492
思路：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 238
要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。判断对称二叉树，比较的是两个树（这两个树是根节点的左右子树），比较的是两个子树的里侧和外侧的元素是否相等。思路：把每一个节点的左右孩子交换一下，使用前序遍历和后序遍历。别忘记空节点，数值不相同的情况。
代码随想录算法训练营Day 13|Python|层序遍历，226.翻转二叉树，101.对称二叉树
qq_60959261的博客
04-03 685
设置一个新的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 946
二叉树：层序遍历、反转二叉树、对称二叉树
代码随想录算法训练营day15 | 层序遍历 10，226.翻转二叉树，101.对称二叉树 2
2301_77450803的博客
04-19 372
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
代码随想录算法训练营第十五天 | 层序遍历 ， 226.翻转二叉树 ， 101.对称二叉树 2
m0_52419043的博客
04-18 277
其实就是遍历二叉树的应用，这里面要注意的思路，只要将所有节点的左右孩子都交换就行，所以目标是遍历所有的节点并对每一节点进行操作（也就是交换左右孩子），所以才可以对原始的二叉树进行遍历。Node*是定义树的，用node->children[ i ]来说明孩子，node->children.size()表示孩子的长度。迭代法，跟遍历的区别就是 每次操作要两个对应的节点，插入的时候也是对应的插入。（最小值），然后更新就可以了。递归法：其实就是遍历左子树，然后对应的遍历右子树。
代码随想录训练营Day15|层序遍历|226.翻转二叉树|101.对称二叉树 2
yy19991222的博客
06-21 305
借助队列结构，保存每一层保存过的元素，size记录当前层大小，决定当前层弹出多少元素；弹出一个元素，就在后续加入他的左右子元素；一层结束，size==0后，队列中全为下一层元素，此时更新size，开始进行该层的弹出，以及下一层的压入。117.填充每个节点的下一个右侧节点指针II。116.填充每个节点的下一个右侧节点指针。107.二叉树的层次遍历II。如何一层一层的保存节点？102.二叉树的层序遍历。637.二叉树的层平均值。104.二叉树的最大深度。111.二叉树的最小深度。199.二叉树的右视图。
代码随想录算法训练营刷题Day15|层序遍历10、226.翻转二叉树、101.对称二叉树 2
weixin_43446964的博客
04-23 230
199：给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。2、具体过程：将节点加入队列；记录当前层的节点个数；弹出有节点个数的节点，并将左右子节点加入队列。2、第一次写没写出来，思路出错，就想用层序遍历再额外加一个数据结构去写，但是有很多问题。4、注意记录每次弹出的次数，而且不能用que.size()，因为que的长度是变化的。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）：给你一个二叉树的根节点。：给你二叉树的根节点。：给你二叉树的根节点。
代码随想录算法训练营Day15 | ● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2
2401_82757749的博客
06-05 519
首先当左右结点都为空时，代表这两个树相等，而当其中一个为空，或者是数值都不相等的时候，肯定是不相等的，这样我们的减枝工作就完成了，下面的情况就是数值相等的情况，下面就是要看他们的结点是不是对称的了，对称看的是左节点的节点是不是和右节点的右节点相等，和左节点的右节点是不是和右节点的左节点相等，然后定于两个bool类型的变量outside和inside用来记录这两个子树是否相等，然后返回即可。二叉树的层序遍历主要是通过队列这种数据结构来实现的，下面来看第一题，这题还是很简单的，直接上代码。
【代码随想录训练营】【Day15】第六章｜二叉树｜层序遍历｜226.翻转二叉树｜101.对称二叉树
士多啤梨先生の博客
02-15 2120
【代码随想录训练营】【Day15】第六章｜二叉树｜层序遍历｜226.翻转二叉树｜101.对称二叉树
python-leetcode面试题解之第102题二叉树的层序遍历-题解.zip
04-29
此外，掌握层序遍历不仅对解决LeetCode题目有帮助，也是面试其他数据结构和算法问题的基础，如二叉树的镜像、判断两棵树是否相同等。 总结来说，Python LeetCode面试题解中的第102题——二叉树的层序遍历，是学习和...
（补）算法训练Day15 | LeetCode226. 翻转二叉树（10种遍历方式的应用）；LeetCode101. 对称二叉树（考查遍历两个二叉树）
weixin_47284299的博客
10-08 646
（补）算法训练Day15 | LeetCode226. 翻转二叉树（10种遍历方式的应用）；LeetCode101. 对称二叉树（考查遍历两个二叉树）
算法：快排(三指针算法)
最新发布
qincjun的博客
11-16 87
快排：三指针算法
C++入门基础知识150—【关于C++ 输入/输出运算符重载】
zhaoylzy的博客
11-16 890
关于【C++输入/输出运算符重载】 一、什么是输入/输出运算符 二、什么是输入输出运算符重载 三、输入输出运算符重载格式 四、输入输出运算符重载参数之间的区别 五、重载提取运算符 >> 和插入运算符
1163：阿克曼(Ackmann)函数
呆萌很的博客
11-12 257
1163：阿克曼(Ackmann)函数
【循环测试试题3】小X与数字三角形
Lonely_Boos的博客
11-16 35
共n行，第i行包含i个正整数，每个整数占五列。读入一个正整数n，输出一个n行的数字三角形。一行一个正整数n，2
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1260
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值